Ifc2x3Enum.h

Go to the documentation of this file.

// Copyright (C) 2002-2019, 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-2019 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
// This file is generated automatically.
 
#ifndef _IFC2X3_ENUM_2x3_H
#define _IFC2X3_ENUM_2x3_H
 
 
using namespace OdIfc;
 
namespace OdIfc2x3 {
 
typedef OdDAI::OdLogical Logical;
typedef OdDAI::OdLogical IfcLogical;
 
enum IfcActionSourceTypeEnum_
{
  kIfcActionSourceTypeEnum_DEAD_LOAD_G,
  kIfcActionSourceTypeEnum_COMPLETION_G1,
  kIfcActionSourceTypeEnum_LIVE_LOAD_Q,
  kIfcActionSourceTypeEnum_SNOW_S,
  kIfcActionSourceTypeEnum_WIND_W,
  kIfcActionSourceTypeEnum_PRESTRESSING_P,
  kIfcActionSourceTypeEnum_SETTLEMENT_U,
  kIfcActionSourceTypeEnum_TEMPERATURE_T,
  kIfcActionSourceTypeEnum_EARTHQUAKE_E,
  kIfcActionSourceTypeEnum_FIRE,
  kIfcActionSourceTypeEnum_IMPULSE,
  kIfcActionSourceTypeEnum_IMPACT,
  kIfcActionSourceTypeEnum_TRANSPORT,
  kIfcActionSourceTypeEnum_ERECTION,
  kIfcActionSourceTypeEnum_PROPPING,
  kIfcActionSourceTypeEnum_SYSTEM_IMPERFECTION,
  kIfcActionSourceTypeEnum_SHRINKAGE,
  kIfcActionSourceTypeEnum_CREEP,
  kIfcActionSourceTypeEnum_LACK_OF_FIT,
  kIfcActionSourceTypeEnum_BUOYANCY,
  kIfcActionSourceTypeEnum_ICE,
  kIfcActionSourceTypeEnum_CURRENT,
  kIfcActionSourceTypeEnum_WAVE,
  kIfcActionSourceTypeEnum_RAIN,
  kIfcActionSourceTypeEnum_BRAKES,
  kIfcActionSourceTypeEnum_USERDEFINED,
  kIfcActionSourceTypeEnum_NOTDEFINED,
  kIfcActionSourceTypeEnum_unset
};
 
class IfcActionSourceTypeEnum {
  IfcActionSourceTypeEnum_ m_val;
public:
  IfcActionSourceTypeEnum() : m_val(kIfcActionSourceTypeEnum_unset) {};
  IfcActionSourceTypeEnum(const IfcActionSourceTypeEnum &other) : m_val(other.m_val) {};
  IfcActionSourceTypeEnum(IfcActionSourceTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcActionSourceTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcActionSourceTypeEnum_unset; };
  operator IfcActionSourceTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcActionSourceTypeEnum& operator = (const IfcActionSourceTypeEnum_ val) { if (val < kIfcActionSourceTypeEnum_unset) m_val = val; else m_val = kIfcActionSourceTypeEnum_unset; return *this; };
  bool operator == (const IfcActionSourceTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcActionSourceTypeEnum &in);
IfcActionSourceTypeEnum StrToIfcActionSourceTypeEnum(OdAnsiString val);
enum IfcActionTypeEnum_
{
  kIfcActionTypeEnum_PERMANENT_G,
  kIfcActionTypeEnum_VARIABLE_Q,
  kIfcActionTypeEnum_EXTRAORDINARY_A,
  kIfcActionTypeEnum_USERDEFINED,
  kIfcActionTypeEnum_NOTDEFINED,
  kIfcActionTypeEnum_unset
};
 
class IfcActionTypeEnum {
  IfcActionTypeEnum_ m_val;
public:
  IfcActionTypeEnum() : m_val(kIfcActionTypeEnum_unset) {};
  IfcActionTypeEnum(const IfcActionTypeEnum &other) : m_val(other.m_val) {};
  IfcActionTypeEnum(IfcActionTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcActionTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcActionTypeEnum_unset; };
  operator IfcActionTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcActionTypeEnum& operator = (const IfcActionTypeEnum_ val) { if (val < kIfcActionTypeEnum_unset) m_val = val; else m_val = kIfcActionTypeEnum_unset; return *this; };
  bool operator == (const IfcActionTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcActionTypeEnum &in);
IfcActionTypeEnum StrToIfcActionTypeEnum(OdAnsiString val);
enum IfcActuatorTypeEnum_
{
  kIfcActuatorTypeEnum_ELECTRICACTUATOR,
  kIfcActuatorTypeEnum_HANDOPERATEDACTUATOR,
  kIfcActuatorTypeEnum_HYDRAULICACTUATOR,
  kIfcActuatorTypeEnum_PNEUMATICACTUATOR,
  kIfcActuatorTypeEnum_THERMOSTATICACTUATOR,
  kIfcActuatorTypeEnum_USERDEFINED,
  kIfcActuatorTypeEnum_NOTDEFINED,
  kIfcActuatorTypeEnum_unset
};
 
class IfcActuatorTypeEnum {
  IfcActuatorTypeEnum_ m_val;
public:
  IfcActuatorTypeEnum() : m_val(kIfcActuatorTypeEnum_unset) {};
  IfcActuatorTypeEnum(const IfcActuatorTypeEnum &other) : m_val(other.m_val) {};
  IfcActuatorTypeEnum(IfcActuatorTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcActuatorTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcActuatorTypeEnum_unset; };
  operator IfcActuatorTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcActuatorTypeEnum& operator = (const IfcActuatorTypeEnum_ val) { if (val < kIfcActuatorTypeEnum_unset) m_val = val; else m_val = kIfcActuatorTypeEnum_unset; return *this; };
  bool operator == (const IfcActuatorTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcActuatorTypeEnum &in);
IfcActuatorTypeEnum StrToIfcActuatorTypeEnum(OdAnsiString val);
enum IfcAddressTypeEnum_
{
  kIfcAddressTypeEnum_OFFICE,
  kIfcAddressTypeEnum_SITE,
  kIfcAddressTypeEnum_HOME,
  kIfcAddressTypeEnum_DISTRIBUTIONPOINT,
  kIfcAddressTypeEnum_USERDEFINED,
  kIfcAddressTypeEnum_unset
};
 
class IfcAddressTypeEnum {
  IfcAddressTypeEnum_ m_val;
public:
  IfcAddressTypeEnum() : m_val(kIfcAddressTypeEnum_unset) {};
  IfcAddressTypeEnum(const IfcAddressTypeEnum &other) : m_val(other.m_val) {};
  IfcAddressTypeEnum(IfcAddressTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcAddressTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcAddressTypeEnum_unset; };
  operator IfcAddressTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcAddressTypeEnum& operator = (const IfcAddressTypeEnum_ val) { if (val < kIfcAddressTypeEnum_unset) m_val = val; else m_val = kIfcAddressTypeEnum_unset; return *this; };
  bool operator == (const IfcAddressTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcAddressTypeEnum &in);
IfcAddressTypeEnum StrToIfcAddressTypeEnum(OdAnsiString val);
enum IfcAheadOrBehind_
{
  kIfcAheadOrBehind_AHEAD,
  kIfcAheadOrBehind_BEHIND,
  kIfcAheadOrBehind_unset
};
 
class IfcAheadOrBehind {
  IfcAheadOrBehind_ m_val;
public:
  IfcAheadOrBehind() : m_val(kIfcAheadOrBehind_unset) {};
  IfcAheadOrBehind(const IfcAheadOrBehind &other) : m_val(other.m_val) {};
  IfcAheadOrBehind(IfcAheadOrBehind_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcAheadOrBehind_unset ? 1 : 0; };
  void nullify() { m_val = kIfcAheadOrBehind_unset; };
  operator IfcAheadOrBehind_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcAheadOrBehind& operator = (const IfcAheadOrBehind_ val) { if (val < kIfcAheadOrBehind_unset) m_val = val; else m_val = kIfcAheadOrBehind_unset; return *this; };
  bool operator == (const IfcAheadOrBehind &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcAheadOrBehind &in);
IfcAheadOrBehind StrToIfcAheadOrBehind(OdAnsiString val);
enum IfcAirTerminalBoxTypeEnum_
{
  kIfcAirTerminalBoxTypeEnum_CONSTANTFLOW,
  kIfcAirTerminalBoxTypeEnum_VARIABLEFLOWPRESSUREDEPENDANT,
  kIfcAirTerminalBoxTypeEnum_VARIABLEFLOWPRESSUREINDEPENDANT,
  kIfcAirTerminalBoxTypeEnum_USERDEFINED,
  kIfcAirTerminalBoxTypeEnum_NOTDEFINED,
  kIfcAirTerminalBoxTypeEnum_unset
};
 
class IfcAirTerminalBoxTypeEnum {
  IfcAirTerminalBoxTypeEnum_ m_val;
public:
  IfcAirTerminalBoxTypeEnum() : m_val(kIfcAirTerminalBoxTypeEnum_unset) {};
  IfcAirTerminalBoxTypeEnum(const IfcAirTerminalBoxTypeEnum &other) : m_val(other.m_val) {};
  IfcAirTerminalBoxTypeEnum(IfcAirTerminalBoxTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcAirTerminalBoxTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcAirTerminalBoxTypeEnum_unset; };
  operator IfcAirTerminalBoxTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcAirTerminalBoxTypeEnum& operator = (const IfcAirTerminalBoxTypeEnum_ val) { if (val < kIfcAirTerminalBoxTypeEnum_unset) m_val = val; else m_val = kIfcAirTerminalBoxTypeEnum_unset; return *this; };
  bool operator == (const IfcAirTerminalBoxTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcAirTerminalBoxTypeEnum &in);
IfcAirTerminalBoxTypeEnum StrToIfcAirTerminalBoxTypeEnum(OdAnsiString val);
enum IfcAirTerminalTypeEnum_
{
  kIfcAirTerminalTypeEnum_GRILLE,
  kIfcAirTerminalTypeEnum_REGISTER,
  kIfcAirTerminalTypeEnum_DIFFUSER,
  kIfcAirTerminalTypeEnum_EYEBALL,
  kIfcAirTerminalTypeEnum_IRIS,
  kIfcAirTerminalTypeEnum_LINEARGRILLE,
  kIfcAirTerminalTypeEnum_LINEARDIFFUSER,
  kIfcAirTerminalTypeEnum_USERDEFINED,
  kIfcAirTerminalTypeEnum_NOTDEFINED,
  kIfcAirTerminalTypeEnum_unset
};
 
class IfcAirTerminalTypeEnum {
  IfcAirTerminalTypeEnum_ m_val;
public:
  IfcAirTerminalTypeEnum() : m_val(kIfcAirTerminalTypeEnum_unset) {};
  IfcAirTerminalTypeEnum(const IfcAirTerminalTypeEnum &other) : m_val(other.m_val) {};
  IfcAirTerminalTypeEnum(IfcAirTerminalTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcAirTerminalTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcAirTerminalTypeEnum_unset; };
  operator IfcAirTerminalTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcAirTerminalTypeEnum& operator = (const IfcAirTerminalTypeEnum_ val) { if (val < kIfcAirTerminalTypeEnum_unset) m_val = val; else m_val = kIfcAirTerminalTypeEnum_unset; return *this; };
  bool operator == (const IfcAirTerminalTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcAirTerminalTypeEnum &in);
IfcAirTerminalTypeEnum StrToIfcAirTerminalTypeEnum(OdAnsiString val);
enum IfcAirToAirHeatRecoveryTypeEnum_
{
  kIfcAirToAirHeatRecoveryTypeEnum_FIXEDPLATECOUNTERFLOWEXCHANGER,
  kIfcAirToAirHeatRecoveryTypeEnum_FIXEDPLATECROSSFLOWEXCHANGER,
  kIfcAirToAirHeatRecoveryTypeEnum_FIXEDPLATEPARALLELFLOWEXCHANGER,
  kIfcAirToAirHeatRecoveryTypeEnum_ROTARYWHEEL,
  kIfcAirToAirHeatRecoveryTypeEnum_RUNAROUNDCOILLOOP,
  kIfcAirToAirHeatRecoveryTypeEnum_HEATPIPE,
  kIfcAirToAirHeatRecoveryTypeEnum_TWINTOWERENTHALPYRECOVERYLOOPS,
  kIfcAirToAirHeatRecoveryTypeEnum_THERMOSIPHONSEALEDTUBEHEATEXCHANGERS,
  kIfcAirToAirHeatRecoveryTypeEnum_THERMOSIPHONCOILTYPEHEATEXCHANGERS,
  kIfcAirToAirHeatRecoveryTypeEnum_USERDEFINED,
  kIfcAirToAirHeatRecoveryTypeEnum_NOTDEFINED,
  kIfcAirToAirHeatRecoveryTypeEnum_unset
};
 
class IfcAirToAirHeatRecoveryTypeEnum {
  IfcAirToAirHeatRecoveryTypeEnum_ m_val;
public:
  IfcAirToAirHeatRecoveryTypeEnum() : m_val(kIfcAirToAirHeatRecoveryTypeEnum_unset) {};
  IfcAirToAirHeatRecoveryTypeEnum(const IfcAirToAirHeatRecoveryTypeEnum &other) : m_val(other.m_val) {};
  IfcAirToAirHeatRecoveryTypeEnum(IfcAirToAirHeatRecoveryTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcAirToAirHeatRecoveryTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcAirToAirHeatRecoveryTypeEnum_unset; };
  operator IfcAirToAirHeatRecoveryTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcAirToAirHeatRecoveryTypeEnum& operator = (const IfcAirToAirHeatRecoveryTypeEnum_ val) { if (val < kIfcAirToAirHeatRecoveryTypeEnum_unset) m_val = val; else m_val = kIfcAirToAirHeatRecoveryTypeEnum_unset; return *this; };
  bool operator == (const IfcAirToAirHeatRecoveryTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcAirToAirHeatRecoveryTypeEnum &in);
IfcAirToAirHeatRecoveryTypeEnum StrToIfcAirToAirHeatRecoveryTypeEnum(OdAnsiString val);
enum IfcAlarmTypeEnum_
{
  kIfcAlarmTypeEnum_BELL,
  kIfcAlarmTypeEnum_BREAKGLASSBUTTON,
  kIfcAlarmTypeEnum_LIGHT,
  kIfcAlarmTypeEnum_MANUALPULLBOX,
  kIfcAlarmTypeEnum_SIREN,
  kIfcAlarmTypeEnum_WHISTLE,
  kIfcAlarmTypeEnum_USERDEFINED,
  kIfcAlarmTypeEnum_NOTDEFINED,
  kIfcAlarmTypeEnum_unset
};
 
class IfcAlarmTypeEnum {
  IfcAlarmTypeEnum_ m_val;
public:
  IfcAlarmTypeEnum() : m_val(kIfcAlarmTypeEnum_unset) {};
  IfcAlarmTypeEnum(const IfcAlarmTypeEnum &other) : m_val(other.m_val) {};
  IfcAlarmTypeEnum(IfcAlarmTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcAlarmTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcAlarmTypeEnum_unset; };
  operator IfcAlarmTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcAlarmTypeEnum& operator = (const IfcAlarmTypeEnum_ val) { if (val < kIfcAlarmTypeEnum_unset) m_val = val; else m_val = kIfcAlarmTypeEnum_unset; return *this; };
  bool operator == (const IfcAlarmTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcAlarmTypeEnum &in);
IfcAlarmTypeEnum StrToIfcAlarmTypeEnum(OdAnsiString val);
enum IfcAnalysisModelTypeEnum_
{
  kIfcAnalysisModelTypeEnum_IN_PLANE_LOADING_2D,
  kIfcAnalysisModelTypeEnum_OUT_PLANE_LOADING_2D,
  kIfcAnalysisModelTypeEnum_LOADING_3D,
  kIfcAnalysisModelTypeEnum_USERDEFINED,
  kIfcAnalysisModelTypeEnum_NOTDEFINED,
  kIfcAnalysisModelTypeEnum_unset
};
 
class IfcAnalysisModelTypeEnum {
  IfcAnalysisModelTypeEnum_ m_val;
public:
  IfcAnalysisModelTypeEnum() : m_val(kIfcAnalysisModelTypeEnum_unset) {};
  IfcAnalysisModelTypeEnum(const IfcAnalysisModelTypeEnum &other) : m_val(other.m_val) {};
  IfcAnalysisModelTypeEnum(IfcAnalysisModelTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcAnalysisModelTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcAnalysisModelTypeEnum_unset; };
  operator IfcAnalysisModelTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcAnalysisModelTypeEnum& operator = (const IfcAnalysisModelTypeEnum_ val) { if (val < kIfcAnalysisModelTypeEnum_unset) m_val = val; else m_val = kIfcAnalysisModelTypeEnum_unset; return *this; };
  bool operator == (const IfcAnalysisModelTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcAnalysisModelTypeEnum &in);
IfcAnalysisModelTypeEnum StrToIfcAnalysisModelTypeEnum(OdAnsiString val);
enum IfcAnalysisTheoryTypeEnum_
{
  kIfcAnalysisTheoryTypeEnum_FIRST_ORDER_THEORY,
  kIfcAnalysisTheoryTypeEnum_SECOND_ORDER_THEORY,
  kIfcAnalysisTheoryTypeEnum_THIRD_ORDER_THEORY,
  kIfcAnalysisTheoryTypeEnum_FULL_NONLINEAR_THEORY,
  kIfcAnalysisTheoryTypeEnum_USERDEFINED,
  kIfcAnalysisTheoryTypeEnum_NOTDEFINED,
  kIfcAnalysisTheoryTypeEnum_unset
};
 
class IfcAnalysisTheoryTypeEnum {
  IfcAnalysisTheoryTypeEnum_ m_val;
public:
  IfcAnalysisTheoryTypeEnum() : m_val(kIfcAnalysisTheoryTypeEnum_unset) {};
  IfcAnalysisTheoryTypeEnum(const IfcAnalysisTheoryTypeEnum &other) : m_val(other.m_val) {};
  IfcAnalysisTheoryTypeEnum(IfcAnalysisTheoryTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcAnalysisTheoryTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcAnalysisTheoryTypeEnum_unset; };
  operator IfcAnalysisTheoryTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcAnalysisTheoryTypeEnum& operator = (const IfcAnalysisTheoryTypeEnum_ val) { if (val < kIfcAnalysisTheoryTypeEnum_unset) m_val = val; else m_val = kIfcAnalysisTheoryTypeEnum_unset; return *this; };
  bool operator == (const IfcAnalysisTheoryTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcAnalysisTheoryTypeEnum &in);
IfcAnalysisTheoryTypeEnum StrToIfcAnalysisTheoryTypeEnum(OdAnsiString val);
enum IfcArithmeticOperatorEnum_
{
  kIfcArithmeticOperatorEnum_ADD,
  kIfcArithmeticOperatorEnum_DIVIDE,
  kIfcArithmeticOperatorEnum_MULTIPLY,
  kIfcArithmeticOperatorEnum_SUBTRACT,
  kIfcArithmeticOperatorEnum_unset
};
 
class IfcArithmeticOperatorEnum {
  IfcArithmeticOperatorEnum_ m_val;
public:
  IfcArithmeticOperatorEnum() : m_val(kIfcArithmeticOperatorEnum_unset) {};
  IfcArithmeticOperatorEnum(const IfcArithmeticOperatorEnum &other) : m_val(other.m_val) {};
  IfcArithmeticOperatorEnum(IfcArithmeticOperatorEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcArithmeticOperatorEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcArithmeticOperatorEnum_unset; };
  operator IfcArithmeticOperatorEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcArithmeticOperatorEnum& operator = (const IfcArithmeticOperatorEnum_ val) { if (val < kIfcArithmeticOperatorEnum_unset) m_val = val; else m_val = kIfcArithmeticOperatorEnum_unset; return *this; };
  bool operator == (const IfcArithmeticOperatorEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcArithmeticOperatorEnum &in);
IfcArithmeticOperatorEnum StrToIfcArithmeticOperatorEnum(OdAnsiString val);
enum IfcAssemblyPlaceEnum_
{
  kIfcAssemblyPlaceEnum_SITE,
  kIfcAssemblyPlaceEnum_FACTORY,
  kIfcAssemblyPlaceEnum_NOTDEFINED,
  kIfcAssemblyPlaceEnum_unset
};
 
class IfcAssemblyPlaceEnum {
  IfcAssemblyPlaceEnum_ m_val;
public:
  IfcAssemblyPlaceEnum() : m_val(kIfcAssemblyPlaceEnum_unset) {};
  IfcAssemblyPlaceEnum(const IfcAssemblyPlaceEnum &other) : m_val(other.m_val) {};
  IfcAssemblyPlaceEnum(IfcAssemblyPlaceEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcAssemblyPlaceEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcAssemblyPlaceEnum_unset; };
  operator IfcAssemblyPlaceEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcAssemblyPlaceEnum& operator = (const IfcAssemblyPlaceEnum_ val) { if (val < kIfcAssemblyPlaceEnum_unset) m_val = val; else m_val = kIfcAssemblyPlaceEnum_unset; return *this; };
  bool operator == (const IfcAssemblyPlaceEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcAssemblyPlaceEnum &in);
IfcAssemblyPlaceEnum StrToIfcAssemblyPlaceEnum(OdAnsiString val);
enum IfcBSplineCurveForm_
{
  kIfcBSplineCurveForm_POLYLINE_FORM,
  kIfcBSplineCurveForm_CIRCULAR_ARC,
  kIfcBSplineCurveForm_ELLIPTIC_ARC,
  kIfcBSplineCurveForm_PARABOLIC_ARC,
  kIfcBSplineCurveForm_HYPERBOLIC_ARC,
  kIfcBSplineCurveForm_UNSPECIFIED,
  kIfcBSplineCurveForm_unset
};
 
class IfcBSplineCurveForm {
  IfcBSplineCurveForm_ m_val;
public:
  IfcBSplineCurveForm() : m_val(kIfcBSplineCurveForm_unset) {};
  IfcBSplineCurveForm(const IfcBSplineCurveForm &other) : m_val(other.m_val) {};
  IfcBSplineCurveForm(IfcBSplineCurveForm_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcBSplineCurveForm_unset ? 1 : 0; };
  void nullify() { m_val = kIfcBSplineCurveForm_unset; };
  operator IfcBSplineCurveForm_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcBSplineCurveForm& operator = (const IfcBSplineCurveForm_ val) { if (val < kIfcBSplineCurveForm_unset) m_val = val; else m_val = kIfcBSplineCurveForm_unset; return *this; };
  bool operator == (const IfcBSplineCurveForm &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcBSplineCurveForm &in);
IfcBSplineCurveForm StrToIfcBSplineCurveForm(OdAnsiString val);
enum IfcBeamTypeEnum_
{
  kIfcBeamTypeEnum_BEAM,
  kIfcBeamTypeEnum_JOIST,
  kIfcBeamTypeEnum_LINTEL,
  kIfcBeamTypeEnum_T_BEAM,
  kIfcBeamTypeEnum_USERDEFINED,
  kIfcBeamTypeEnum_NOTDEFINED,
  kIfcBeamTypeEnum_unset
};
 
class IfcBeamTypeEnum {
  IfcBeamTypeEnum_ m_val;
public:
  IfcBeamTypeEnum() : m_val(kIfcBeamTypeEnum_unset) {};
  IfcBeamTypeEnum(const IfcBeamTypeEnum &other) : m_val(other.m_val) {};
  IfcBeamTypeEnum(IfcBeamTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcBeamTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcBeamTypeEnum_unset; };
  operator IfcBeamTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcBeamTypeEnum& operator = (const IfcBeamTypeEnum_ val) { if (val < kIfcBeamTypeEnum_unset) m_val = val; else m_val = kIfcBeamTypeEnum_unset; return *this; };
  bool operator == (const IfcBeamTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcBeamTypeEnum &in);
IfcBeamTypeEnum StrToIfcBeamTypeEnum(OdAnsiString val);
enum IfcBenchmarkEnum_
{
  kIfcBenchmarkEnum_GREATERTHAN,
  kIfcBenchmarkEnum_GREATERTHANOREQUALTO,
  kIfcBenchmarkEnum_LESSTHAN,
  kIfcBenchmarkEnum_LESSTHANOREQUALTO,
  kIfcBenchmarkEnum_EQUALTO,
  kIfcBenchmarkEnum_NOTEQUALTO,
  kIfcBenchmarkEnum_unset
};
 
class IfcBenchmarkEnum {
  IfcBenchmarkEnum_ m_val;
public:
  IfcBenchmarkEnum() : m_val(kIfcBenchmarkEnum_unset) {};
  IfcBenchmarkEnum(const IfcBenchmarkEnum &other) : m_val(other.m_val) {};
  IfcBenchmarkEnum(IfcBenchmarkEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcBenchmarkEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcBenchmarkEnum_unset; };
  operator IfcBenchmarkEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcBenchmarkEnum& operator = (const IfcBenchmarkEnum_ val) { if (val < kIfcBenchmarkEnum_unset) m_val = val; else m_val = kIfcBenchmarkEnum_unset; return *this; };
  bool operator == (const IfcBenchmarkEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcBenchmarkEnum &in);
IfcBenchmarkEnum StrToIfcBenchmarkEnum(OdAnsiString val);
enum IfcBoilerTypeEnum_
{
  kIfcBoilerTypeEnum_WATER,
  kIfcBoilerTypeEnum_STEAM,
  kIfcBoilerTypeEnum_USERDEFINED,
  kIfcBoilerTypeEnum_NOTDEFINED,
  kIfcBoilerTypeEnum_unset
};
 
class IfcBoilerTypeEnum {
  IfcBoilerTypeEnum_ m_val;
public:
  IfcBoilerTypeEnum() : m_val(kIfcBoilerTypeEnum_unset) {};
  IfcBoilerTypeEnum(const IfcBoilerTypeEnum &other) : m_val(other.m_val) {};
  IfcBoilerTypeEnum(IfcBoilerTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcBoilerTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcBoilerTypeEnum_unset; };
  operator IfcBoilerTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcBoilerTypeEnum& operator = (const IfcBoilerTypeEnum_ val) { if (val < kIfcBoilerTypeEnum_unset) m_val = val; else m_val = kIfcBoilerTypeEnum_unset; return *this; };
  bool operator == (const IfcBoilerTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcBoilerTypeEnum &in);
IfcBoilerTypeEnum StrToIfcBoilerTypeEnum(OdAnsiString val);
enum IfcBooleanOperator_
{
  kIfcBooleanOperator_UNION,
  kIfcBooleanOperator_INTERSECTION,
  kIfcBooleanOperator_DIFFERENCE,
  kIfcBooleanOperator_unset
};
 
class IfcBooleanOperator {
  IfcBooleanOperator_ m_val;
public:
  IfcBooleanOperator() : m_val(kIfcBooleanOperator_unset) {};
  IfcBooleanOperator(const IfcBooleanOperator &other) : m_val(other.m_val) {};
  IfcBooleanOperator(IfcBooleanOperator_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcBooleanOperator_unset ? 1 : 0; };
  void nullify() { m_val = kIfcBooleanOperator_unset; };
  operator IfcBooleanOperator_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcBooleanOperator& operator = (const IfcBooleanOperator_ val) { if (val < kIfcBooleanOperator_unset) m_val = val; else m_val = kIfcBooleanOperator_unset; return *this; };
  bool operator == (const IfcBooleanOperator &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcBooleanOperator &in);
IfcBooleanOperator StrToIfcBooleanOperator(OdAnsiString val);
enum IfcBuildingElementProxyTypeEnum_
{
  kIfcBuildingElementProxyTypeEnum_USERDEFINED,
  kIfcBuildingElementProxyTypeEnum_NOTDEFINED,
  kIfcBuildingElementProxyTypeEnum_unset
};
 
class IfcBuildingElementProxyTypeEnum {
  IfcBuildingElementProxyTypeEnum_ m_val;
public:
  IfcBuildingElementProxyTypeEnum() : m_val(kIfcBuildingElementProxyTypeEnum_unset) {};
  IfcBuildingElementProxyTypeEnum(const IfcBuildingElementProxyTypeEnum &other) : m_val(other.m_val) {};
  IfcBuildingElementProxyTypeEnum(IfcBuildingElementProxyTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcBuildingElementProxyTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcBuildingElementProxyTypeEnum_unset; };
  operator IfcBuildingElementProxyTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcBuildingElementProxyTypeEnum& operator = (const IfcBuildingElementProxyTypeEnum_ val) { if (val < kIfcBuildingElementProxyTypeEnum_unset) m_val = val; else m_val = kIfcBuildingElementProxyTypeEnum_unset; return *this; };
  bool operator == (const IfcBuildingElementProxyTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcBuildingElementProxyTypeEnum &in);
IfcBuildingElementProxyTypeEnum StrToIfcBuildingElementProxyTypeEnum(OdAnsiString val);
enum IfcCableCarrierFittingTypeEnum_
{
  kIfcCableCarrierFittingTypeEnum_BEND,
  kIfcCableCarrierFittingTypeEnum_CROSS,
  kIfcCableCarrierFittingTypeEnum_REDUCER,
  kIfcCableCarrierFittingTypeEnum_TEE,
  kIfcCableCarrierFittingTypeEnum_USERDEFINED,
  kIfcCableCarrierFittingTypeEnum_NOTDEFINED,
  kIfcCableCarrierFittingTypeEnum_unset
};
 
class IfcCableCarrierFittingTypeEnum {
  IfcCableCarrierFittingTypeEnum_ m_val;
public:
  IfcCableCarrierFittingTypeEnum() : m_val(kIfcCableCarrierFittingTypeEnum_unset) {};
  IfcCableCarrierFittingTypeEnum(const IfcCableCarrierFittingTypeEnum &other) : m_val(other.m_val) {};
  IfcCableCarrierFittingTypeEnum(IfcCableCarrierFittingTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcCableCarrierFittingTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcCableCarrierFittingTypeEnum_unset; };
  operator IfcCableCarrierFittingTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcCableCarrierFittingTypeEnum& operator = (const IfcCableCarrierFittingTypeEnum_ val) { if (val < kIfcCableCarrierFittingTypeEnum_unset) m_val = val; else m_val = kIfcCableCarrierFittingTypeEnum_unset; return *this; };
  bool operator == (const IfcCableCarrierFittingTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcCableCarrierFittingTypeEnum &in);
IfcCableCarrierFittingTypeEnum StrToIfcCableCarrierFittingTypeEnum(OdAnsiString val);
enum IfcCableCarrierSegmentTypeEnum_
{
  kIfcCableCarrierSegmentTypeEnum_CABLELADDERSEGMENT,
  kIfcCableCarrierSegmentTypeEnum_CABLETRAYSEGMENT,
  kIfcCableCarrierSegmentTypeEnum_CABLETRUNKINGSEGMENT,
  kIfcCableCarrierSegmentTypeEnum_CONDUITSEGMENT,
  kIfcCableCarrierSegmentTypeEnum_USERDEFINED,
  kIfcCableCarrierSegmentTypeEnum_NOTDEFINED,
  kIfcCableCarrierSegmentTypeEnum_unset
};
 
class IfcCableCarrierSegmentTypeEnum {
  IfcCableCarrierSegmentTypeEnum_ m_val;
public:
  IfcCableCarrierSegmentTypeEnum() : m_val(kIfcCableCarrierSegmentTypeEnum_unset) {};
  IfcCableCarrierSegmentTypeEnum(const IfcCableCarrierSegmentTypeEnum &other) : m_val(other.m_val) {};
  IfcCableCarrierSegmentTypeEnum(IfcCableCarrierSegmentTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcCableCarrierSegmentTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcCableCarrierSegmentTypeEnum_unset; };
  operator IfcCableCarrierSegmentTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcCableCarrierSegmentTypeEnum& operator = (const IfcCableCarrierSegmentTypeEnum_ val) { if (val < kIfcCableCarrierSegmentTypeEnum_unset) m_val = val; else m_val = kIfcCableCarrierSegmentTypeEnum_unset; return *this; };
  bool operator == (const IfcCableCarrierSegmentTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcCableCarrierSegmentTypeEnum &in);
IfcCableCarrierSegmentTypeEnum StrToIfcCableCarrierSegmentTypeEnum(OdAnsiString val);
enum IfcCableSegmentTypeEnum_
{
  kIfcCableSegmentTypeEnum_CABLESEGMENT,
  kIfcCableSegmentTypeEnum_CONDUCTORSEGMENT,
  kIfcCableSegmentTypeEnum_USERDEFINED,
  kIfcCableSegmentTypeEnum_NOTDEFINED,
  kIfcCableSegmentTypeEnum_unset
};
 
class IfcCableSegmentTypeEnum {
  IfcCableSegmentTypeEnum_ m_val;
public:
  IfcCableSegmentTypeEnum() : m_val(kIfcCableSegmentTypeEnum_unset) {};
  IfcCableSegmentTypeEnum(const IfcCableSegmentTypeEnum &other) : m_val(other.m_val) {};
  IfcCableSegmentTypeEnum(IfcCableSegmentTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcCableSegmentTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcCableSegmentTypeEnum_unset; };
  operator IfcCableSegmentTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcCableSegmentTypeEnum& operator = (const IfcCableSegmentTypeEnum_ val) { if (val < kIfcCableSegmentTypeEnum_unset) m_val = val; else m_val = kIfcCableSegmentTypeEnum_unset; return *this; };
  bool operator == (const IfcCableSegmentTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcCableSegmentTypeEnum &in);
IfcCableSegmentTypeEnum StrToIfcCableSegmentTypeEnum(OdAnsiString val);
enum IfcChangeActionEnum_
{
  kIfcChangeActionEnum_NOCHANGE,
  kIfcChangeActionEnum_MODIFIED,
  kIfcChangeActionEnum_ADDED,
  kIfcChangeActionEnum_DELETED,
  kIfcChangeActionEnum_MODIFIEDADDED,
  kIfcChangeActionEnum_MODIFIEDDELETED,
  kIfcChangeActionEnum_unset
};
 
class IfcChangeActionEnum {
  IfcChangeActionEnum_ m_val;
public:
  IfcChangeActionEnum() : m_val(kIfcChangeActionEnum_unset) {};
  IfcChangeActionEnum(const IfcChangeActionEnum &other) : m_val(other.m_val) {};
  IfcChangeActionEnum(IfcChangeActionEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcChangeActionEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcChangeActionEnum_unset; };
  operator IfcChangeActionEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcChangeActionEnum& operator = (const IfcChangeActionEnum_ val) { if (val < kIfcChangeActionEnum_unset) m_val = val; else m_val = kIfcChangeActionEnum_unset; return *this; };
  bool operator == (const IfcChangeActionEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcChangeActionEnum &in);
IfcChangeActionEnum StrToIfcChangeActionEnum(OdAnsiString val);
enum IfcChillerTypeEnum_
{
  kIfcChillerTypeEnum_AIRCOOLED,
  kIfcChillerTypeEnum_WATERCOOLED,
  kIfcChillerTypeEnum_HEATRECOVERY,
  kIfcChillerTypeEnum_USERDEFINED,
  kIfcChillerTypeEnum_NOTDEFINED,
  kIfcChillerTypeEnum_unset
};
 
class IfcChillerTypeEnum {
  IfcChillerTypeEnum_ m_val;
public:
  IfcChillerTypeEnum() : m_val(kIfcChillerTypeEnum_unset) {};
  IfcChillerTypeEnum(const IfcChillerTypeEnum &other) : m_val(other.m_val) {};
  IfcChillerTypeEnum(IfcChillerTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcChillerTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcChillerTypeEnum_unset; };
  operator IfcChillerTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcChillerTypeEnum& operator = (const IfcChillerTypeEnum_ val) { if (val < kIfcChillerTypeEnum_unset) m_val = val; else m_val = kIfcChillerTypeEnum_unset; return *this; };
  bool operator == (const IfcChillerTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcChillerTypeEnum &in);
IfcChillerTypeEnum StrToIfcChillerTypeEnum(OdAnsiString val);
enum IfcCoilTypeEnum_
{
  kIfcCoilTypeEnum_DXCOOLINGCOIL,
  kIfcCoilTypeEnum_WATERCOOLINGCOIL,
  kIfcCoilTypeEnum_STEAMHEATINGCOIL,
  kIfcCoilTypeEnum_WATERHEATINGCOIL,
  kIfcCoilTypeEnum_ELECTRICHEATINGCOIL,
  kIfcCoilTypeEnum_GASHEATINGCOIL,
  kIfcCoilTypeEnum_USERDEFINED,
  kIfcCoilTypeEnum_NOTDEFINED,
  kIfcCoilTypeEnum_unset
};
 
class IfcCoilTypeEnum {
  IfcCoilTypeEnum_ m_val;
public:
  IfcCoilTypeEnum() : m_val(kIfcCoilTypeEnum_unset) {};
  IfcCoilTypeEnum(const IfcCoilTypeEnum &other) : m_val(other.m_val) {};
  IfcCoilTypeEnum(IfcCoilTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcCoilTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcCoilTypeEnum_unset; };
  operator IfcCoilTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcCoilTypeEnum& operator = (const IfcCoilTypeEnum_ val) { if (val < kIfcCoilTypeEnum_unset) m_val = val; else m_val = kIfcCoilTypeEnum_unset; return *this; };
  bool operator == (const IfcCoilTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcCoilTypeEnum &in);
IfcCoilTypeEnum StrToIfcCoilTypeEnum(OdAnsiString val);
enum IfcColumnTypeEnum_
{
  kIfcColumnTypeEnum_COLUMN,
  kIfcColumnTypeEnum_USERDEFINED,
  kIfcColumnTypeEnum_NOTDEFINED,
  kIfcColumnTypeEnum_unset
};
 
class IfcColumnTypeEnum {
  IfcColumnTypeEnum_ m_val;
public:
  IfcColumnTypeEnum() : m_val(kIfcColumnTypeEnum_unset) {};
  IfcColumnTypeEnum(const IfcColumnTypeEnum &other) : m_val(other.m_val) {};
  IfcColumnTypeEnum(IfcColumnTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcColumnTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcColumnTypeEnum_unset; };
  operator IfcColumnTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcColumnTypeEnum& operator = (const IfcColumnTypeEnum_ val) { if (val < kIfcColumnTypeEnum_unset) m_val = val; else m_val = kIfcColumnTypeEnum_unset; return *this; };
  bool operator == (const IfcColumnTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcColumnTypeEnum &in);
IfcColumnTypeEnum StrToIfcColumnTypeEnum(OdAnsiString val);
enum IfcCompressorTypeEnum_
{
  kIfcCompressorTypeEnum_DYNAMIC,
  kIfcCompressorTypeEnum_RECIPROCATING,
  kIfcCompressorTypeEnum_ROTARY,
  kIfcCompressorTypeEnum_SCROLL,
  kIfcCompressorTypeEnum_TROCHOIDAL,
  kIfcCompressorTypeEnum_SINGLESTAGE,
  kIfcCompressorTypeEnum_BOOSTER,
  kIfcCompressorTypeEnum_OPENTYPE,
  kIfcCompressorTypeEnum_HERMETIC,
  kIfcCompressorTypeEnum_SEMIHERMETIC,
  kIfcCompressorTypeEnum_WELDEDSHELLHERMETIC,
  kIfcCompressorTypeEnum_ROLLINGPISTON,
  kIfcCompressorTypeEnum_ROTARYVANE,
  kIfcCompressorTypeEnum_SINGLESCREW,
  kIfcCompressorTypeEnum_TWINSCREW,
  kIfcCompressorTypeEnum_USERDEFINED,
  kIfcCompressorTypeEnum_NOTDEFINED,
  kIfcCompressorTypeEnum_unset
};
 
class IfcCompressorTypeEnum {
  IfcCompressorTypeEnum_ m_val;
public:
  IfcCompressorTypeEnum() : m_val(kIfcCompressorTypeEnum_unset) {};
  IfcCompressorTypeEnum(const IfcCompressorTypeEnum &other) : m_val(other.m_val) {};
  IfcCompressorTypeEnum(IfcCompressorTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcCompressorTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcCompressorTypeEnum_unset; };
  operator IfcCompressorTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcCompressorTypeEnum& operator = (const IfcCompressorTypeEnum_ val) { if (val < kIfcCompressorTypeEnum_unset) m_val = val; else m_val = kIfcCompressorTypeEnum_unset; return *this; };
  bool operator == (const IfcCompressorTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcCompressorTypeEnum &in);
IfcCompressorTypeEnum StrToIfcCompressorTypeEnum(OdAnsiString val);
enum IfcCondenserTypeEnum_
{
  kIfcCondenserTypeEnum_WATERCOOLEDSHELLTUBE,
  kIfcCondenserTypeEnum_WATERCOOLEDSHELLCOIL,
  kIfcCondenserTypeEnum_WATERCOOLEDTUBEINTUBE,
  kIfcCondenserTypeEnum_WATERCOOLEDBRAZEDPLATE,
  kIfcCondenserTypeEnum_AIRCOOLED,
  kIfcCondenserTypeEnum_EVAPORATIVECOOLED,
  kIfcCondenserTypeEnum_USERDEFINED,
  kIfcCondenserTypeEnum_NOTDEFINED,
  kIfcCondenserTypeEnum_unset
};
 
class IfcCondenserTypeEnum {
  IfcCondenserTypeEnum_ m_val;
public:
  IfcCondenserTypeEnum() : m_val(kIfcCondenserTypeEnum_unset) {};
  IfcCondenserTypeEnum(const IfcCondenserTypeEnum &other) : m_val(other.m_val) {};
  IfcCondenserTypeEnum(IfcCondenserTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcCondenserTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcCondenserTypeEnum_unset; };
  operator IfcCondenserTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcCondenserTypeEnum& operator = (const IfcCondenserTypeEnum_ val) { if (val < kIfcCondenserTypeEnum_unset) m_val = val; else m_val = kIfcCondenserTypeEnum_unset; return *this; };
  bool operator == (const IfcCondenserTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcCondenserTypeEnum &in);
IfcCondenserTypeEnum StrToIfcCondenserTypeEnum(OdAnsiString val);
enum IfcConnectionTypeEnum_
{
  kIfcConnectionTypeEnum_ATPATH,
  kIfcConnectionTypeEnum_ATSTART,
  kIfcConnectionTypeEnum_ATEND,
  kIfcConnectionTypeEnum_NOTDEFINED,
  kIfcConnectionTypeEnum_unset
};
 
class IfcConnectionTypeEnum {
  IfcConnectionTypeEnum_ m_val;
public:
  IfcConnectionTypeEnum() : m_val(kIfcConnectionTypeEnum_unset) {};
  IfcConnectionTypeEnum(const IfcConnectionTypeEnum &other) : m_val(other.m_val) {};
  IfcConnectionTypeEnum(IfcConnectionTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcConnectionTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcConnectionTypeEnum_unset; };
  operator IfcConnectionTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcConnectionTypeEnum& operator = (const IfcConnectionTypeEnum_ val) { if (val < kIfcConnectionTypeEnum_unset) m_val = val; else m_val = kIfcConnectionTypeEnum_unset; return *this; };
  bool operator == (const IfcConnectionTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcConnectionTypeEnum &in);
IfcConnectionTypeEnum StrToIfcConnectionTypeEnum(OdAnsiString val);
enum IfcConstraintEnum_
{
  kIfcConstraintEnum_HARD,
  kIfcConstraintEnum_SOFT,
  kIfcConstraintEnum_ADVISORY,
  kIfcConstraintEnum_USERDEFINED,
  kIfcConstraintEnum_NOTDEFINED,
  kIfcConstraintEnum_unset
};
 
class IfcConstraintEnum {
  IfcConstraintEnum_ m_val;
public:
  IfcConstraintEnum() : m_val(kIfcConstraintEnum_unset) {};
  IfcConstraintEnum(const IfcConstraintEnum &other) : m_val(other.m_val) {};
  IfcConstraintEnum(IfcConstraintEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcConstraintEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcConstraintEnum_unset; };
  operator IfcConstraintEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcConstraintEnum& operator = (const IfcConstraintEnum_ val) { if (val < kIfcConstraintEnum_unset) m_val = val; else m_val = kIfcConstraintEnum_unset; return *this; };
  bool operator == (const IfcConstraintEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcConstraintEnum &in);
IfcConstraintEnum StrToIfcConstraintEnum(OdAnsiString val);
enum IfcControllerTypeEnum_
{
  kIfcControllerTypeEnum_FLOATING,
  kIfcControllerTypeEnum_PROPORTIONAL,
  kIfcControllerTypeEnum_PROPORTIONALINTEGRAL,
  kIfcControllerTypeEnum_PROPORTIONALINTEGRALDERIVATIVE,
  kIfcControllerTypeEnum_TIMEDTWOPOSITION,
  kIfcControllerTypeEnum_TWOPOSITION,
  kIfcControllerTypeEnum_USERDEFINED,
  kIfcControllerTypeEnum_NOTDEFINED,
  kIfcControllerTypeEnum_unset
};
 
class IfcControllerTypeEnum {
  IfcControllerTypeEnum_ m_val;
public:
  IfcControllerTypeEnum() : m_val(kIfcControllerTypeEnum_unset) {};
  IfcControllerTypeEnum(const IfcControllerTypeEnum &other) : m_val(other.m_val) {};
  IfcControllerTypeEnum(IfcControllerTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcControllerTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcControllerTypeEnum_unset; };
  operator IfcControllerTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcControllerTypeEnum& operator = (const IfcControllerTypeEnum_ val) { if (val < kIfcControllerTypeEnum_unset) m_val = val; else m_val = kIfcControllerTypeEnum_unset; return *this; };
  bool operator == (const IfcControllerTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcControllerTypeEnum &in);
IfcControllerTypeEnum StrToIfcControllerTypeEnum(OdAnsiString val);
enum IfcCooledBeamTypeEnum_
{
  kIfcCooledBeamTypeEnum_ACTIVE,
  kIfcCooledBeamTypeEnum_PASSIVE,
  kIfcCooledBeamTypeEnum_USERDEFINED,
  kIfcCooledBeamTypeEnum_NOTDEFINED,
  kIfcCooledBeamTypeEnum_unset
};
 
class IfcCooledBeamTypeEnum {
  IfcCooledBeamTypeEnum_ m_val;
public:
  IfcCooledBeamTypeEnum() : m_val(kIfcCooledBeamTypeEnum_unset) {};
  IfcCooledBeamTypeEnum(const IfcCooledBeamTypeEnum &other) : m_val(other.m_val) {};
  IfcCooledBeamTypeEnum(IfcCooledBeamTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcCooledBeamTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcCooledBeamTypeEnum_unset; };
  operator IfcCooledBeamTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcCooledBeamTypeEnum& operator = (const IfcCooledBeamTypeEnum_ val) { if (val < kIfcCooledBeamTypeEnum_unset) m_val = val; else m_val = kIfcCooledBeamTypeEnum_unset; return *this; };
  bool operator == (const IfcCooledBeamTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcCooledBeamTypeEnum &in);
IfcCooledBeamTypeEnum StrToIfcCooledBeamTypeEnum(OdAnsiString val);
enum IfcCoolingTowerTypeEnum_
{
  kIfcCoolingTowerTypeEnum_NATURALDRAFT,
  kIfcCoolingTowerTypeEnum_MECHANICALINDUCEDDRAFT,
  kIfcCoolingTowerTypeEnum_MECHANICALFORCEDDRAFT,
  kIfcCoolingTowerTypeEnum_USERDEFINED,
  kIfcCoolingTowerTypeEnum_NOTDEFINED,
  kIfcCoolingTowerTypeEnum_unset
};
 
class IfcCoolingTowerTypeEnum {
  IfcCoolingTowerTypeEnum_ m_val;
public:
  IfcCoolingTowerTypeEnum() : m_val(kIfcCoolingTowerTypeEnum_unset) {};
  IfcCoolingTowerTypeEnum(const IfcCoolingTowerTypeEnum &other) : m_val(other.m_val) {};
  IfcCoolingTowerTypeEnum(IfcCoolingTowerTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcCoolingTowerTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcCoolingTowerTypeEnum_unset; };
  operator IfcCoolingTowerTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcCoolingTowerTypeEnum& operator = (const IfcCoolingTowerTypeEnum_ val) { if (val < kIfcCoolingTowerTypeEnum_unset) m_val = val; else m_val = kIfcCoolingTowerTypeEnum_unset; return *this; };
  bool operator == (const IfcCoolingTowerTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcCoolingTowerTypeEnum &in);
IfcCoolingTowerTypeEnum StrToIfcCoolingTowerTypeEnum(OdAnsiString val);
enum IfcCostScheduleTypeEnum_
{
  kIfcCostScheduleTypeEnum_BUDGET,
  kIfcCostScheduleTypeEnum_COSTPLAN,
  kIfcCostScheduleTypeEnum_ESTIMATE,
  kIfcCostScheduleTypeEnum_TENDER,
  kIfcCostScheduleTypeEnum_PRICEDBILLOFQUANTITIES,
  kIfcCostScheduleTypeEnum_UNPRICEDBILLOFQUANTITIES,
  kIfcCostScheduleTypeEnum_SCHEDULEOFRATES,
  kIfcCostScheduleTypeEnum_USERDEFINED,
  kIfcCostScheduleTypeEnum_NOTDEFINED,
  kIfcCostScheduleTypeEnum_unset
};
 
class IfcCostScheduleTypeEnum {
  IfcCostScheduleTypeEnum_ m_val;
public:
  IfcCostScheduleTypeEnum() : m_val(kIfcCostScheduleTypeEnum_unset) {};
  IfcCostScheduleTypeEnum(const IfcCostScheduleTypeEnum &other) : m_val(other.m_val) {};
  IfcCostScheduleTypeEnum(IfcCostScheduleTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcCostScheduleTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcCostScheduleTypeEnum_unset; };
  operator IfcCostScheduleTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcCostScheduleTypeEnum& operator = (const IfcCostScheduleTypeEnum_ val) { if (val < kIfcCostScheduleTypeEnum_unset) m_val = val; else m_val = kIfcCostScheduleTypeEnum_unset; return *this; };
  bool operator == (const IfcCostScheduleTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcCostScheduleTypeEnum &in);
IfcCostScheduleTypeEnum StrToIfcCostScheduleTypeEnum(OdAnsiString val);
enum IfcCoveringTypeEnum_
{
  kIfcCoveringTypeEnum_CEILING,
  kIfcCoveringTypeEnum_FLOORING,
  kIfcCoveringTypeEnum_CLADDING,
  kIfcCoveringTypeEnum_ROOFING,
  kIfcCoveringTypeEnum_INSULATION,
  kIfcCoveringTypeEnum_MEMBRANE,
  kIfcCoveringTypeEnum_SLEEVING,
  kIfcCoveringTypeEnum_WRAPPING,
  kIfcCoveringTypeEnum_USERDEFINED,
  kIfcCoveringTypeEnum_NOTDEFINED,
  kIfcCoveringTypeEnum_unset
};
 
class IfcCoveringTypeEnum {
  IfcCoveringTypeEnum_ m_val;
public:
  IfcCoveringTypeEnum() : m_val(kIfcCoveringTypeEnum_unset) {};
  IfcCoveringTypeEnum(const IfcCoveringTypeEnum &other) : m_val(other.m_val) {};
  IfcCoveringTypeEnum(IfcCoveringTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcCoveringTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcCoveringTypeEnum_unset; };
  operator IfcCoveringTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcCoveringTypeEnum& operator = (const IfcCoveringTypeEnum_ val) { if (val < kIfcCoveringTypeEnum_unset) m_val = val; else m_val = kIfcCoveringTypeEnum_unset; return *this; };
  bool operator == (const IfcCoveringTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcCoveringTypeEnum &in);
IfcCoveringTypeEnum StrToIfcCoveringTypeEnum(OdAnsiString val);
enum IfcCurrencyEnum_
{
  kIfcCurrencyEnum_AED,
  kIfcCurrencyEnum_AES,
  kIfcCurrencyEnum_ATS,
  kIfcCurrencyEnum_AUD,
  kIfcCurrencyEnum_BBD,
  kIfcCurrencyEnum_BEG,
  kIfcCurrencyEnum_BGL,
  kIfcCurrencyEnum_BHD,
  kIfcCurrencyEnum_BMD,
  kIfcCurrencyEnum_BND,
  kIfcCurrencyEnum_BRL,
  kIfcCurrencyEnum_BSD,
  kIfcCurrencyEnum_BWP,
  kIfcCurrencyEnum_BZD,
  kIfcCurrencyEnum_CAD,
  kIfcCurrencyEnum_CBD,
  kIfcCurrencyEnum_CHF,
  kIfcCurrencyEnum_CLP,
  kIfcCurrencyEnum_CNY,
  kIfcCurrencyEnum_CYS,
  kIfcCurrencyEnum_CZK,
  kIfcCurrencyEnum_DDP,
  kIfcCurrencyEnum_DEM,
  kIfcCurrencyEnum_DKK,
  kIfcCurrencyEnum_EGL,
  kIfcCurrencyEnum_EST,
  kIfcCurrencyEnum_EUR,
  kIfcCurrencyEnum_FAK,
  kIfcCurrencyEnum_FIM,
  kIfcCurrencyEnum_FJD,
  kIfcCurrencyEnum_FKP,
  kIfcCurrencyEnum_FRF,
  kIfcCurrencyEnum_GBP,
  kIfcCurrencyEnum_GIP,
  kIfcCurrencyEnum_GMD,
  kIfcCurrencyEnum_GRX,
  kIfcCurrencyEnum_HKD,
  kIfcCurrencyEnum_HUF,
  kIfcCurrencyEnum_ICK,
  kIfcCurrencyEnum_IDR,
  kIfcCurrencyEnum_ILS,
  kIfcCurrencyEnum_INR,
  kIfcCurrencyEnum_IRP,
  kIfcCurrencyEnum_ITL,
  kIfcCurrencyEnum_JMD,
  kIfcCurrencyEnum_JOD,
  kIfcCurrencyEnum_JPY,
  kIfcCurrencyEnum_KES,
  kIfcCurrencyEnum_KRW,
  kIfcCurrencyEnum_KWD,
  kIfcCurrencyEnum_KYD,
  kIfcCurrencyEnum_LKR,
  kIfcCurrencyEnum_LUF,
  kIfcCurrencyEnum_MTL,
  kIfcCurrencyEnum_MUR,
  kIfcCurrencyEnum_MXN,
  kIfcCurrencyEnum_MYR,
  kIfcCurrencyEnum_NLG,
  kIfcCurrencyEnum_NZD,
  kIfcCurrencyEnum_OMR,
  kIfcCurrencyEnum_PGK,
  kIfcCurrencyEnum_PHP,
  kIfcCurrencyEnum_PKR,
  kIfcCurrencyEnum_PLN,
  kIfcCurrencyEnum_PTN,
  kIfcCurrencyEnum_QAR,
  kIfcCurrencyEnum_RUR,
  kIfcCurrencyEnum_SAR,
  kIfcCurrencyEnum_SCR,
  kIfcCurrencyEnum_SEK,
  kIfcCurrencyEnum_SGD,
  kIfcCurrencyEnum_SKP,
  kIfcCurrencyEnum_THB,
  kIfcCurrencyEnum_TRL,
  kIfcCurrencyEnum_TTD,
  kIfcCurrencyEnum_TWD,
  kIfcCurrencyEnum_USD,
  kIfcCurrencyEnum_VEB,
  kIfcCurrencyEnum_VND,
  kIfcCurrencyEnum_XEU,
  kIfcCurrencyEnum_ZAR,
  kIfcCurrencyEnum_ZWD,
  kIfcCurrencyEnum_NOK,
  kIfcCurrencyEnum_unset
};
 
class IfcCurrencyEnum {
  IfcCurrencyEnum_ m_val;
public:
  IfcCurrencyEnum() : m_val(kIfcCurrencyEnum_unset) {};
  IfcCurrencyEnum(const IfcCurrencyEnum &other) : m_val(other.m_val) {};
  IfcCurrencyEnum(IfcCurrencyEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcCurrencyEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcCurrencyEnum_unset; };
  operator IfcCurrencyEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcCurrencyEnum& operator = (const IfcCurrencyEnum_ val) { if (val < kIfcCurrencyEnum_unset) m_val = val; else m_val = kIfcCurrencyEnum_unset; return *this; };
  bool operator == (const IfcCurrencyEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcCurrencyEnum &in);
IfcCurrencyEnum StrToIfcCurrencyEnum(OdAnsiString val);
enum IfcCurtainWallTypeEnum_
{
  kIfcCurtainWallTypeEnum_USERDEFINED,
  kIfcCurtainWallTypeEnum_NOTDEFINED,
  kIfcCurtainWallTypeEnum_unset
};
 
class IfcCurtainWallTypeEnum {
  IfcCurtainWallTypeEnum_ m_val;
public:
  IfcCurtainWallTypeEnum() : m_val(kIfcCurtainWallTypeEnum_unset) {};
  IfcCurtainWallTypeEnum(const IfcCurtainWallTypeEnum &other) : m_val(other.m_val) {};
  IfcCurtainWallTypeEnum(IfcCurtainWallTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcCurtainWallTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcCurtainWallTypeEnum_unset; };
  operator IfcCurtainWallTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcCurtainWallTypeEnum& operator = (const IfcCurtainWallTypeEnum_ val) { if (val < kIfcCurtainWallTypeEnum_unset) m_val = val; else m_val = kIfcCurtainWallTypeEnum_unset; return *this; };
  bool operator == (const IfcCurtainWallTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcCurtainWallTypeEnum &in);
IfcCurtainWallTypeEnum StrToIfcCurtainWallTypeEnum(OdAnsiString val);
enum IfcDamperTypeEnum_
{
  kIfcDamperTypeEnum_CONTROLDAMPER,
  kIfcDamperTypeEnum_FIREDAMPER,
  kIfcDamperTypeEnum_SMOKEDAMPER,
  kIfcDamperTypeEnum_FIRESMOKEDAMPER,
  kIfcDamperTypeEnum_BACKDRAFTDAMPER,
  kIfcDamperTypeEnum_RELIEFDAMPER,
  kIfcDamperTypeEnum_BLASTDAMPER,
  kIfcDamperTypeEnum_GRAVITYDAMPER,
  kIfcDamperTypeEnum_GRAVITYRELIEFDAMPER,
  kIfcDamperTypeEnum_BALANCINGDAMPER,
  kIfcDamperTypeEnum_FUMEHOODEXHAUST,
  kIfcDamperTypeEnum_USERDEFINED,
  kIfcDamperTypeEnum_NOTDEFINED,
  kIfcDamperTypeEnum_unset
};
 
class IfcDamperTypeEnum {
  IfcDamperTypeEnum_ m_val;
public:
  IfcDamperTypeEnum() : m_val(kIfcDamperTypeEnum_unset) {};
  IfcDamperTypeEnum(const IfcDamperTypeEnum &other) : m_val(other.m_val) {};
  IfcDamperTypeEnum(IfcDamperTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcDamperTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcDamperTypeEnum_unset; };
  operator IfcDamperTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcDamperTypeEnum& operator = (const IfcDamperTypeEnum_ val) { if (val < kIfcDamperTypeEnum_unset) m_val = val; else m_val = kIfcDamperTypeEnum_unset; return *this; };
  bool operator == (const IfcDamperTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcDamperTypeEnum &in);
IfcDamperTypeEnum StrToIfcDamperTypeEnum(OdAnsiString val);
enum IfcDataOriginEnum_
{
  kIfcDataOriginEnum_MEASURED,
  kIfcDataOriginEnum_PREDICTED,
  kIfcDataOriginEnum_SIMULATED,
  kIfcDataOriginEnum_USERDEFINED,
  kIfcDataOriginEnum_NOTDEFINED,
  kIfcDataOriginEnum_unset
};
 
class IfcDataOriginEnum {
  IfcDataOriginEnum_ m_val;
public:
  IfcDataOriginEnum() : m_val(kIfcDataOriginEnum_unset) {};
  IfcDataOriginEnum(const IfcDataOriginEnum &other) : m_val(other.m_val) {};
  IfcDataOriginEnum(IfcDataOriginEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcDataOriginEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcDataOriginEnum_unset; };
  operator IfcDataOriginEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcDataOriginEnum& operator = (const IfcDataOriginEnum_ val) { if (val < kIfcDataOriginEnum_unset) m_val = val; else m_val = kIfcDataOriginEnum_unset; return *this; };
  bool operator == (const IfcDataOriginEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcDataOriginEnum &in);
IfcDataOriginEnum StrToIfcDataOriginEnum(OdAnsiString val);
enum IfcDerivedUnitEnum_
{
  kIfcDerivedUnitEnum_ANGULARVELOCITYUNIT,
  kIfcDerivedUnitEnum_COMPOUNDPLANEANGLEUNIT,
  kIfcDerivedUnitEnum_DYNAMICVISCOSITYUNIT,
  kIfcDerivedUnitEnum_HEATFLUXDENSITYUNIT,
  kIfcDerivedUnitEnum_INTEGERCOUNTRATEUNIT,
  kIfcDerivedUnitEnum_ISOTHERMALMOISTURECAPACITYUNIT,
  kIfcDerivedUnitEnum_KINEMATICVISCOSITYUNIT,
  kIfcDerivedUnitEnum_LINEARVELOCITYUNIT,
  kIfcDerivedUnitEnum_MASSDENSITYUNIT,
  kIfcDerivedUnitEnum_MASSFLOWRATEUNIT,
  kIfcDerivedUnitEnum_MOISTUREDIFFUSIVITYUNIT,
  kIfcDerivedUnitEnum_MOLECULARWEIGHTUNIT,
  kIfcDerivedUnitEnum_SPECIFICHEATCAPACITYUNIT,
  kIfcDerivedUnitEnum_THERMALADMITTANCEUNIT,
  kIfcDerivedUnitEnum_THERMALCONDUCTANCEUNIT,
  kIfcDerivedUnitEnum_THERMALRESISTANCEUNIT,
  kIfcDerivedUnitEnum_THERMALTRANSMITTANCEUNIT,
  kIfcDerivedUnitEnum_VAPORPERMEABILITYUNIT,
  kIfcDerivedUnitEnum_VOLUMETRICFLOWRATEUNIT,
  kIfcDerivedUnitEnum_ROTATIONALFREQUENCYUNIT,
  kIfcDerivedUnitEnum_TORQUEUNIT,
  kIfcDerivedUnitEnum_MOMENTOFINERTIAUNIT,
  kIfcDerivedUnitEnum_LINEARMOMENTUNIT,
  kIfcDerivedUnitEnum_LINEARFORCEUNIT,
  kIfcDerivedUnitEnum_PLANARFORCEUNIT,
  kIfcDerivedUnitEnum_MODULUSOFELASTICITYUNIT,
  kIfcDerivedUnitEnum_SHEARMODULUSUNIT,
  kIfcDerivedUnitEnum_LINEARSTIFFNESSUNIT,
  kIfcDerivedUnitEnum_ROTATIONALSTIFFNESSUNIT,
  kIfcDerivedUnitEnum_MODULUSOFSUBGRADEREACTIONUNIT,
  kIfcDerivedUnitEnum_ACCELERATIONUNIT,
  kIfcDerivedUnitEnum_CURVATUREUNIT,
  kIfcDerivedUnitEnum_HEATINGVALUEUNIT,
  kIfcDerivedUnitEnum_IONCONCENTRATIONUNIT,
  kIfcDerivedUnitEnum_LUMINOUSINTENSITYDISTRIBUTIONUNIT,
  kIfcDerivedUnitEnum_MASSPERLENGTHUNIT,
  kIfcDerivedUnitEnum_MODULUSOFLINEARSUBGRADEREACTIONUNIT,
  kIfcDerivedUnitEnum_MODULUSOFROTATIONALSUBGRADEREACTIONUNIT,
  kIfcDerivedUnitEnum_PHUNIT,
  kIfcDerivedUnitEnum_ROTATIONALMASSUNIT,
  kIfcDerivedUnitEnum_SECTIONAREAINTEGRALUNIT,
  kIfcDerivedUnitEnum_SECTIONMODULUSUNIT,
  kIfcDerivedUnitEnum_SOUNDPOWERUNIT,
  kIfcDerivedUnitEnum_SOUNDPRESSUREUNIT,
  kIfcDerivedUnitEnum_TEMPERATUREGRADIENTUNIT,
  kIfcDerivedUnitEnum_THERMALEXPANSIONCOEFFICIENTUNIT,
  kIfcDerivedUnitEnum_WARPINGCONSTANTUNIT,
  kIfcDerivedUnitEnum_WARPINGMOMENTUNIT,
  kIfcDerivedUnitEnum_USERDEFINED,
  kIfcDerivedUnitEnum_unset
};
 
class IfcDerivedUnitEnum {
  IfcDerivedUnitEnum_ m_val;
public:
  IfcDerivedUnitEnum() : m_val(kIfcDerivedUnitEnum_unset) {};
  IfcDerivedUnitEnum(const IfcDerivedUnitEnum &other) : m_val(other.m_val) {};
  IfcDerivedUnitEnum(IfcDerivedUnitEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcDerivedUnitEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcDerivedUnitEnum_unset; };
  operator IfcDerivedUnitEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcDerivedUnitEnum& operator = (const IfcDerivedUnitEnum_ val) { if (val < kIfcDerivedUnitEnum_unset) m_val = val; else m_val = kIfcDerivedUnitEnum_unset; return *this; };
  bool operator == (const IfcDerivedUnitEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcDerivedUnitEnum &in);
IfcDerivedUnitEnum StrToIfcDerivedUnitEnum(OdAnsiString val);
enum IfcDimensionExtentUsage_
{
  kIfcDimensionExtentUsage_ORIGIN,
  kIfcDimensionExtentUsage_TARGET,
  kIfcDimensionExtentUsage_unset
};
 
class IfcDimensionExtentUsage {
  IfcDimensionExtentUsage_ m_val;
public:
  IfcDimensionExtentUsage() : m_val(kIfcDimensionExtentUsage_unset) {};
  IfcDimensionExtentUsage(const IfcDimensionExtentUsage &other) : m_val(other.m_val) {};
  IfcDimensionExtentUsage(IfcDimensionExtentUsage_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcDimensionExtentUsage_unset ? 1 : 0; };
  void nullify() { m_val = kIfcDimensionExtentUsage_unset; };
  operator IfcDimensionExtentUsage_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcDimensionExtentUsage& operator = (const IfcDimensionExtentUsage_ val) { if (val < kIfcDimensionExtentUsage_unset) m_val = val; else m_val = kIfcDimensionExtentUsage_unset; return *this; };
  bool operator == (const IfcDimensionExtentUsage &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcDimensionExtentUsage &in);
IfcDimensionExtentUsage StrToIfcDimensionExtentUsage(OdAnsiString val);
enum IfcDirectionSenseEnum_
{
  kIfcDirectionSenseEnum_POSITIVE,
  kIfcDirectionSenseEnum_NEGATIVE,
  kIfcDirectionSenseEnum_unset
};
 
class IfcDirectionSenseEnum {
  IfcDirectionSenseEnum_ m_val;
public:
  IfcDirectionSenseEnum() : m_val(kIfcDirectionSenseEnum_unset) {};
  IfcDirectionSenseEnum(const IfcDirectionSenseEnum &other) : m_val(other.m_val) {};
  IfcDirectionSenseEnum(IfcDirectionSenseEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcDirectionSenseEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcDirectionSenseEnum_unset; };
  operator IfcDirectionSenseEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcDirectionSenseEnum& operator = (const IfcDirectionSenseEnum_ val) { if (val < kIfcDirectionSenseEnum_unset) m_val = val; else m_val = kIfcDirectionSenseEnum_unset; return *this; };
  bool operator == (const IfcDirectionSenseEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcDirectionSenseEnum &in);
IfcDirectionSenseEnum StrToIfcDirectionSenseEnum(OdAnsiString val);
enum IfcDistributionChamberElementTypeEnum_
{
  kIfcDistributionChamberElementTypeEnum_FORMEDDUCT,
  kIfcDistributionChamberElementTypeEnum_INSPECTIONCHAMBER,
  kIfcDistributionChamberElementTypeEnum_INSPECTIONPIT,
  kIfcDistributionChamberElementTypeEnum_MANHOLE,
  kIfcDistributionChamberElementTypeEnum_METERCHAMBER,
  kIfcDistributionChamberElementTypeEnum_SUMP,
  kIfcDistributionChamberElementTypeEnum_TRENCH,
  kIfcDistributionChamberElementTypeEnum_VALVECHAMBER,
  kIfcDistributionChamberElementTypeEnum_USERDEFINED,
  kIfcDistributionChamberElementTypeEnum_NOTDEFINED,
  kIfcDistributionChamberElementTypeEnum_unset
};
 
class IfcDistributionChamberElementTypeEnum {
  IfcDistributionChamberElementTypeEnum_ m_val;
public:
  IfcDistributionChamberElementTypeEnum() : m_val(kIfcDistributionChamberElementTypeEnum_unset) {};
  IfcDistributionChamberElementTypeEnum(const IfcDistributionChamberElementTypeEnum &other) : m_val(other.m_val) {};
  IfcDistributionChamberElementTypeEnum(IfcDistributionChamberElementTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcDistributionChamberElementTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcDistributionChamberElementTypeEnum_unset; };
  operator IfcDistributionChamberElementTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcDistributionChamberElementTypeEnum& operator = (const IfcDistributionChamberElementTypeEnum_ val) { if (val < kIfcDistributionChamberElementTypeEnum_unset) m_val = val; else m_val = kIfcDistributionChamberElementTypeEnum_unset; return *this; };
  bool operator == (const IfcDistributionChamberElementTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcDistributionChamberElementTypeEnum &in);
IfcDistributionChamberElementTypeEnum StrToIfcDistributionChamberElementTypeEnum(OdAnsiString val);
enum IfcDocumentConfidentialityEnum_
{
  kIfcDocumentConfidentialityEnum_PUBLIC,
  kIfcDocumentConfidentialityEnum_RESTRICTED,
  kIfcDocumentConfidentialityEnum_CONFIDENTIAL,
  kIfcDocumentConfidentialityEnum_PERSONAL,
  kIfcDocumentConfidentialityEnum_USERDEFINED,
  kIfcDocumentConfidentialityEnum_NOTDEFINED,
  kIfcDocumentConfidentialityEnum_unset
};
 
class IfcDocumentConfidentialityEnum {
  IfcDocumentConfidentialityEnum_ m_val;
public:
  IfcDocumentConfidentialityEnum() : m_val(kIfcDocumentConfidentialityEnum_unset) {};
  IfcDocumentConfidentialityEnum(const IfcDocumentConfidentialityEnum &other) : m_val(other.m_val) {};
  IfcDocumentConfidentialityEnum(IfcDocumentConfidentialityEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcDocumentConfidentialityEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcDocumentConfidentialityEnum_unset; };
  operator IfcDocumentConfidentialityEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcDocumentConfidentialityEnum& operator = (const IfcDocumentConfidentialityEnum_ val) { if (val < kIfcDocumentConfidentialityEnum_unset) m_val = val; else m_val = kIfcDocumentConfidentialityEnum_unset; return *this; };
  bool operator == (const IfcDocumentConfidentialityEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcDocumentConfidentialityEnum &in);
IfcDocumentConfidentialityEnum StrToIfcDocumentConfidentialityEnum(OdAnsiString val);
enum IfcDocumentStatusEnum_
{
  kIfcDocumentStatusEnum_DRAFT,
  kIfcDocumentStatusEnum_FINALDRAFT,
  kIfcDocumentStatusEnum_FINAL,
  kIfcDocumentStatusEnum_REVISION,
  kIfcDocumentStatusEnum_NOTDEFINED,
  kIfcDocumentStatusEnum_unset
};
 
class IfcDocumentStatusEnum {
  IfcDocumentStatusEnum_ m_val;
public:
  IfcDocumentStatusEnum() : m_val(kIfcDocumentStatusEnum_unset) {};
  IfcDocumentStatusEnum(const IfcDocumentStatusEnum &other) : m_val(other.m_val) {};
  IfcDocumentStatusEnum(IfcDocumentStatusEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcDocumentStatusEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcDocumentStatusEnum_unset; };
  operator IfcDocumentStatusEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcDocumentStatusEnum& operator = (const IfcDocumentStatusEnum_ val) { if (val < kIfcDocumentStatusEnum_unset) m_val = val; else m_val = kIfcDocumentStatusEnum_unset; return *this; };
  bool operator == (const IfcDocumentStatusEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcDocumentStatusEnum &in);
IfcDocumentStatusEnum StrToIfcDocumentStatusEnum(OdAnsiString val);
enum IfcDoorPanelOperationEnum_
{
  kIfcDoorPanelOperationEnum_SWINGING,
  kIfcDoorPanelOperationEnum_DOUBLE_ACTING,
  kIfcDoorPanelOperationEnum_SLIDING,
  kIfcDoorPanelOperationEnum_FOLDING,
  kIfcDoorPanelOperationEnum_REVOLVING,
  kIfcDoorPanelOperationEnum_ROLLINGUP,
  kIfcDoorPanelOperationEnum_USERDEFINED,
  kIfcDoorPanelOperationEnum_NOTDEFINED,
  kIfcDoorPanelOperationEnum_unset
};
 
class IfcDoorPanelOperationEnum {
  IfcDoorPanelOperationEnum_ m_val;
public:
  IfcDoorPanelOperationEnum() : m_val(kIfcDoorPanelOperationEnum_unset) {};
  IfcDoorPanelOperationEnum(const IfcDoorPanelOperationEnum &other) : m_val(other.m_val) {};
  IfcDoorPanelOperationEnum(IfcDoorPanelOperationEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcDoorPanelOperationEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcDoorPanelOperationEnum_unset; };
  operator IfcDoorPanelOperationEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcDoorPanelOperationEnum& operator = (const IfcDoorPanelOperationEnum_ val) { if (val < kIfcDoorPanelOperationEnum_unset) m_val = val; else m_val = kIfcDoorPanelOperationEnum_unset; return *this; };
  bool operator == (const IfcDoorPanelOperationEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcDoorPanelOperationEnum &in);
IfcDoorPanelOperationEnum StrToIfcDoorPanelOperationEnum(OdAnsiString val);
enum IfcDoorPanelPositionEnum_
{
  kIfcDoorPanelPositionEnum_LEFT,
  kIfcDoorPanelPositionEnum_MIDDLE,
  kIfcDoorPanelPositionEnum_RIGHT,
  kIfcDoorPanelPositionEnum_NOTDEFINED,
  kIfcDoorPanelPositionEnum_unset
};
 
class IfcDoorPanelPositionEnum {
  IfcDoorPanelPositionEnum_ m_val;
public:
  IfcDoorPanelPositionEnum() : m_val(kIfcDoorPanelPositionEnum_unset) {};
  IfcDoorPanelPositionEnum(const IfcDoorPanelPositionEnum &other) : m_val(other.m_val) {};
  IfcDoorPanelPositionEnum(IfcDoorPanelPositionEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcDoorPanelPositionEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcDoorPanelPositionEnum_unset; };
  operator IfcDoorPanelPositionEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcDoorPanelPositionEnum& operator = (const IfcDoorPanelPositionEnum_ val) { if (val < kIfcDoorPanelPositionEnum_unset) m_val = val; else m_val = kIfcDoorPanelPositionEnum_unset; return *this; };
  bool operator == (const IfcDoorPanelPositionEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcDoorPanelPositionEnum &in);
IfcDoorPanelPositionEnum StrToIfcDoorPanelPositionEnum(OdAnsiString val);
enum IfcDoorStyleConstructionEnum_
{
  kIfcDoorStyleConstructionEnum_ALUMINIUM,
  kIfcDoorStyleConstructionEnum_HIGH_GRADE_STEEL,
  kIfcDoorStyleConstructionEnum_STEEL,
  kIfcDoorStyleConstructionEnum_WOOD,
  kIfcDoorStyleConstructionEnum_ALUMINIUM_WOOD,
  kIfcDoorStyleConstructionEnum_ALUMINIUM_PLASTIC,
  kIfcDoorStyleConstructionEnum_PLASTIC,
  kIfcDoorStyleConstructionEnum_USERDEFINED,
  kIfcDoorStyleConstructionEnum_NOTDEFINED,
  kIfcDoorStyleConstructionEnum_unset
};
 
class IfcDoorStyleConstructionEnum {
  IfcDoorStyleConstructionEnum_ m_val;
public:
  IfcDoorStyleConstructionEnum() : m_val(kIfcDoorStyleConstructionEnum_unset) {};
  IfcDoorStyleConstructionEnum(const IfcDoorStyleConstructionEnum &other) : m_val(other.m_val) {};
  IfcDoorStyleConstructionEnum(IfcDoorStyleConstructionEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcDoorStyleConstructionEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcDoorStyleConstructionEnum_unset; };
  operator IfcDoorStyleConstructionEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcDoorStyleConstructionEnum& operator = (const IfcDoorStyleConstructionEnum_ val) { if (val < kIfcDoorStyleConstructionEnum_unset) m_val = val; else m_val = kIfcDoorStyleConstructionEnum_unset; return *this; };
  bool operator == (const IfcDoorStyleConstructionEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcDoorStyleConstructionEnum &in);
IfcDoorStyleConstructionEnum StrToIfcDoorStyleConstructionEnum(OdAnsiString val);
enum IfcDoorStyleOperationEnum_
{
  kIfcDoorStyleOperationEnum_SINGLE_SWING_LEFT,
  kIfcDoorStyleOperationEnum_SINGLE_SWING_RIGHT,
  kIfcDoorStyleOperationEnum_DOUBLE_DOOR_SINGLE_SWING,
  kIfcDoorStyleOperationEnum_DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT,
  kIfcDoorStyleOperationEnum_DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT,
  kIfcDoorStyleOperationEnum_DOUBLE_SWING_LEFT,
  kIfcDoorStyleOperationEnum_DOUBLE_SWING_RIGHT,
  kIfcDoorStyleOperationEnum_DOUBLE_DOOR_DOUBLE_SWING,
  kIfcDoorStyleOperationEnum_SLIDING_TO_LEFT,
  kIfcDoorStyleOperationEnum_SLIDING_TO_RIGHT,
  kIfcDoorStyleOperationEnum_DOUBLE_DOOR_SLIDING,
  kIfcDoorStyleOperationEnum_FOLDING_TO_LEFT,
  kIfcDoorStyleOperationEnum_FOLDING_TO_RIGHT,
  kIfcDoorStyleOperationEnum_DOUBLE_DOOR_FOLDING,
  kIfcDoorStyleOperationEnum_REVOLVING,
  kIfcDoorStyleOperationEnum_ROLLINGUP,
  kIfcDoorStyleOperationEnum_USERDEFINED,
  kIfcDoorStyleOperationEnum_NOTDEFINED,
  kIfcDoorStyleOperationEnum_unset
};
 
class IfcDoorStyleOperationEnum {
  IfcDoorStyleOperationEnum_ m_val;
public:
  IfcDoorStyleOperationEnum() : m_val(kIfcDoorStyleOperationEnum_unset) {};
  IfcDoorStyleOperationEnum(const IfcDoorStyleOperationEnum &other) : m_val(other.m_val) {};
  IfcDoorStyleOperationEnum(IfcDoorStyleOperationEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcDoorStyleOperationEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcDoorStyleOperationEnum_unset; };
  operator IfcDoorStyleOperationEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcDoorStyleOperationEnum& operator = (const IfcDoorStyleOperationEnum_ val) { if (val < kIfcDoorStyleOperationEnum_unset) m_val = val; else m_val = kIfcDoorStyleOperationEnum_unset; return *this; };
  bool operator == (const IfcDoorStyleOperationEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcDoorStyleOperationEnum &in);
IfcDoorStyleOperationEnum StrToIfcDoorStyleOperationEnum(OdAnsiString val);
enum IfcDuctFittingTypeEnum_
{
  kIfcDuctFittingTypeEnum_BEND,
  kIfcDuctFittingTypeEnum_CONNECTOR,
  kIfcDuctFittingTypeEnum_ENTRY,
  kIfcDuctFittingTypeEnum_EXIT,
  kIfcDuctFittingTypeEnum_JUNCTION,
  kIfcDuctFittingTypeEnum_OBSTRUCTION,
  kIfcDuctFittingTypeEnum_TRANSITION,
  kIfcDuctFittingTypeEnum_USERDEFINED,
  kIfcDuctFittingTypeEnum_NOTDEFINED,
  kIfcDuctFittingTypeEnum_unset
};
 
class IfcDuctFittingTypeEnum {
  IfcDuctFittingTypeEnum_ m_val;
public:
  IfcDuctFittingTypeEnum() : m_val(kIfcDuctFittingTypeEnum_unset) {};
  IfcDuctFittingTypeEnum(const IfcDuctFittingTypeEnum &other) : m_val(other.m_val) {};
  IfcDuctFittingTypeEnum(IfcDuctFittingTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcDuctFittingTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcDuctFittingTypeEnum_unset; };
  operator IfcDuctFittingTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcDuctFittingTypeEnum& operator = (const IfcDuctFittingTypeEnum_ val) { if (val < kIfcDuctFittingTypeEnum_unset) m_val = val; else m_val = kIfcDuctFittingTypeEnum_unset; return *this; };
  bool operator == (const IfcDuctFittingTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcDuctFittingTypeEnum &in);
IfcDuctFittingTypeEnum StrToIfcDuctFittingTypeEnum(OdAnsiString val);
enum IfcDuctSegmentTypeEnum_
{
  kIfcDuctSegmentTypeEnum_RIGIDSEGMENT,
  kIfcDuctSegmentTypeEnum_FLEXIBLESEGMENT,
  kIfcDuctSegmentTypeEnum_USERDEFINED,
  kIfcDuctSegmentTypeEnum_NOTDEFINED,
  kIfcDuctSegmentTypeEnum_unset
};
 
class IfcDuctSegmentTypeEnum {
  IfcDuctSegmentTypeEnum_ m_val;
public:
  IfcDuctSegmentTypeEnum() : m_val(kIfcDuctSegmentTypeEnum_unset) {};
  IfcDuctSegmentTypeEnum(const IfcDuctSegmentTypeEnum &other) : m_val(other.m_val) {};
  IfcDuctSegmentTypeEnum(IfcDuctSegmentTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcDuctSegmentTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcDuctSegmentTypeEnum_unset; };
  operator IfcDuctSegmentTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcDuctSegmentTypeEnum& operator = (const IfcDuctSegmentTypeEnum_ val) { if (val < kIfcDuctSegmentTypeEnum_unset) m_val = val; else m_val = kIfcDuctSegmentTypeEnum_unset; return *this; };
  bool operator == (const IfcDuctSegmentTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcDuctSegmentTypeEnum &in);
IfcDuctSegmentTypeEnum StrToIfcDuctSegmentTypeEnum(OdAnsiString val);
enum IfcDuctSilencerTypeEnum_
{
  kIfcDuctSilencerTypeEnum_FLATOVAL,
  kIfcDuctSilencerTypeEnum_RECTANGULAR,
  kIfcDuctSilencerTypeEnum_ROUND,
  kIfcDuctSilencerTypeEnum_USERDEFINED,
  kIfcDuctSilencerTypeEnum_NOTDEFINED,
  kIfcDuctSilencerTypeEnum_unset
};
 
class IfcDuctSilencerTypeEnum {
  IfcDuctSilencerTypeEnum_ m_val;
public:
  IfcDuctSilencerTypeEnum() : m_val(kIfcDuctSilencerTypeEnum_unset) {};
  IfcDuctSilencerTypeEnum(const IfcDuctSilencerTypeEnum &other) : m_val(other.m_val) {};
  IfcDuctSilencerTypeEnum(IfcDuctSilencerTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcDuctSilencerTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcDuctSilencerTypeEnum_unset; };
  operator IfcDuctSilencerTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcDuctSilencerTypeEnum& operator = (const IfcDuctSilencerTypeEnum_ val) { if (val < kIfcDuctSilencerTypeEnum_unset) m_val = val; else m_val = kIfcDuctSilencerTypeEnum_unset; return *this; };
  bool operator == (const IfcDuctSilencerTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcDuctSilencerTypeEnum &in);
IfcDuctSilencerTypeEnum StrToIfcDuctSilencerTypeEnum(OdAnsiString val);
enum IfcElectricApplianceTypeEnum_
{
  kIfcElectricApplianceTypeEnum_COMPUTER,
  kIfcElectricApplianceTypeEnum_DIRECTWATERHEATER,
  kIfcElectricApplianceTypeEnum_DISHWASHER,
  kIfcElectricApplianceTypeEnum_ELECTRICCOOKER,
  kIfcElectricApplianceTypeEnum_ELECTRICHEATER,
  kIfcElectricApplianceTypeEnum_FACSIMILE,
  kIfcElectricApplianceTypeEnum_FREESTANDINGFAN,
  kIfcElectricApplianceTypeEnum_FREEZER,
  kIfcElectricApplianceTypeEnum_FRIDGE_FREEZER,
  kIfcElectricApplianceTypeEnum_HANDDRYER,
  kIfcElectricApplianceTypeEnum_INDIRECTWATERHEATER,
  kIfcElectricApplianceTypeEnum_MICROWAVE,
  kIfcElectricApplianceTypeEnum_PHOTOCOPIER,
  kIfcElectricApplianceTypeEnum_PRINTER,
  kIfcElectricApplianceTypeEnum_REFRIGERATOR,
  kIfcElectricApplianceTypeEnum_RADIANTHEATER,
  kIfcElectricApplianceTypeEnum_SCANNER,
  kIfcElectricApplianceTypeEnum_TELEPHONE,
  kIfcElectricApplianceTypeEnum_TUMBLEDRYER,
  kIfcElectricApplianceTypeEnum_TV,
  kIfcElectricApplianceTypeEnum_VENDINGMACHINE,
  kIfcElectricApplianceTypeEnum_WASHINGMACHINE,
  kIfcElectricApplianceTypeEnum_WATERHEATER,
  kIfcElectricApplianceTypeEnum_WATERCOOLER,
  kIfcElectricApplianceTypeEnum_USERDEFINED,
  kIfcElectricApplianceTypeEnum_NOTDEFINED,
  kIfcElectricApplianceTypeEnum_unset
};
 
class IfcElectricApplianceTypeEnum {
  IfcElectricApplianceTypeEnum_ m_val;
public:
  IfcElectricApplianceTypeEnum() : m_val(kIfcElectricApplianceTypeEnum_unset) {};
  IfcElectricApplianceTypeEnum(const IfcElectricApplianceTypeEnum &other) : m_val(other.m_val) {};
  IfcElectricApplianceTypeEnum(IfcElectricApplianceTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcElectricApplianceTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcElectricApplianceTypeEnum_unset; };
  operator IfcElectricApplianceTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcElectricApplianceTypeEnum& operator = (const IfcElectricApplianceTypeEnum_ val) { if (val < kIfcElectricApplianceTypeEnum_unset) m_val = val; else m_val = kIfcElectricApplianceTypeEnum_unset; return *this; };
  bool operator == (const IfcElectricApplianceTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcElectricApplianceTypeEnum &in);
IfcElectricApplianceTypeEnum StrToIfcElectricApplianceTypeEnum(OdAnsiString val);
enum IfcElectricCurrentEnum_
{
  kIfcElectricCurrentEnum_ALTERNATING,
  kIfcElectricCurrentEnum_DIRECT,
  kIfcElectricCurrentEnum_NOTDEFINED,
  kIfcElectricCurrentEnum_unset
};
 
class IfcElectricCurrentEnum {
  IfcElectricCurrentEnum_ m_val;
public:
  IfcElectricCurrentEnum() : m_val(kIfcElectricCurrentEnum_unset) {};
  IfcElectricCurrentEnum(const IfcElectricCurrentEnum &other) : m_val(other.m_val) {};
  IfcElectricCurrentEnum(IfcElectricCurrentEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcElectricCurrentEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcElectricCurrentEnum_unset; };
  operator IfcElectricCurrentEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcElectricCurrentEnum& operator = (const IfcElectricCurrentEnum_ val) { if (val < kIfcElectricCurrentEnum_unset) m_val = val; else m_val = kIfcElectricCurrentEnum_unset; return *this; };
  bool operator == (const IfcElectricCurrentEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcElectricCurrentEnum &in);
IfcElectricCurrentEnum StrToIfcElectricCurrentEnum(OdAnsiString val);
enum IfcElectricDistributionPointFunctionEnum_
{
  kIfcElectricDistributionPointFunctionEnum_ALARMPANEL,
  kIfcElectricDistributionPointFunctionEnum_CONSUMERUNIT,
  kIfcElectricDistributionPointFunctionEnum_CONTROLPANEL,
  kIfcElectricDistributionPointFunctionEnum_DISTRIBUTIONBOARD,
  kIfcElectricDistributionPointFunctionEnum_GASDETECTORPANEL,
  kIfcElectricDistributionPointFunctionEnum_INDICATORPANEL,
  kIfcElectricDistributionPointFunctionEnum_MIMICPANEL,
  kIfcElectricDistributionPointFunctionEnum_MOTORCONTROLCENTRE,
  kIfcElectricDistributionPointFunctionEnum_SWITCHBOARD,
  kIfcElectricDistributionPointFunctionEnum_USERDEFINED,
  kIfcElectricDistributionPointFunctionEnum_NOTDEFINED,
  kIfcElectricDistributionPointFunctionEnum_unset
};
 
class IfcElectricDistributionPointFunctionEnum {
  IfcElectricDistributionPointFunctionEnum_ m_val;
public:
  IfcElectricDistributionPointFunctionEnum() : m_val(kIfcElectricDistributionPointFunctionEnum_unset) {};
  IfcElectricDistributionPointFunctionEnum(const IfcElectricDistributionPointFunctionEnum &other) : m_val(other.m_val) {};
  IfcElectricDistributionPointFunctionEnum(IfcElectricDistributionPointFunctionEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcElectricDistributionPointFunctionEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcElectricDistributionPointFunctionEnum_unset; };
  operator IfcElectricDistributionPointFunctionEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcElectricDistributionPointFunctionEnum& operator = (const IfcElectricDistributionPointFunctionEnum_ val) { if (val < kIfcElectricDistributionPointFunctionEnum_unset) m_val = val; else m_val = kIfcElectricDistributionPointFunctionEnum_unset; return *this; };
  bool operator == (const IfcElectricDistributionPointFunctionEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcElectricDistributionPointFunctionEnum &in);
IfcElectricDistributionPointFunctionEnum StrToIfcElectricDistributionPointFunctionEnum(OdAnsiString val);
enum IfcElectricFlowStorageDeviceTypeEnum_
{
  kIfcElectricFlowStorageDeviceTypeEnum_BATTERY,
  kIfcElectricFlowStorageDeviceTypeEnum_CAPACITORBANK,
  kIfcElectricFlowStorageDeviceTypeEnum_HARMONICFILTER,
  kIfcElectricFlowStorageDeviceTypeEnum_INDUCTORBANK,
  kIfcElectricFlowStorageDeviceTypeEnum_UPS,
  kIfcElectricFlowStorageDeviceTypeEnum_USERDEFINED,
  kIfcElectricFlowStorageDeviceTypeEnum_NOTDEFINED,
  kIfcElectricFlowStorageDeviceTypeEnum_unset
};
 
class IfcElectricFlowStorageDeviceTypeEnum {
  IfcElectricFlowStorageDeviceTypeEnum_ m_val;
public:
  IfcElectricFlowStorageDeviceTypeEnum() : m_val(kIfcElectricFlowStorageDeviceTypeEnum_unset) {};
  IfcElectricFlowStorageDeviceTypeEnum(const IfcElectricFlowStorageDeviceTypeEnum &other) : m_val(other.m_val) {};
  IfcElectricFlowStorageDeviceTypeEnum(IfcElectricFlowStorageDeviceTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcElectricFlowStorageDeviceTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcElectricFlowStorageDeviceTypeEnum_unset; };
  operator IfcElectricFlowStorageDeviceTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcElectricFlowStorageDeviceTypeEnum& operator = (const IfcElectricFlowStorageDeviceTypeEnum_ val) { if (val < kIfcElectricFlowStorageDeviceTypeEnum_unset) m_val = val; else m_val = kIfcElectricFlowStorageDeviceTypeEnum_unset; return *this; };
  bool operator == (const IfcElectricFlowStorageDeviceTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcElectricFlowStorageDeviceTypeEnum &in);
IfcElectricFlowStorageDeviceTypeEnum StrToIfcElectricFlowStorageDeviceTypeEnum(OdAnsiString val);
enum IfcElectricGeneratorTypeEnum_
{
  kIfcElectricGeneratorTypeEnum_USERDEFINED,
  kIfcElectricGeneratorTypeEnum_NOTDEFINED,
  kIfcElectricGeneratorTypeEnum_unset
};
 
class IfcElectricGeneratorTypeEnum {
  IfcElectricGeneratorTypeEnum_ m_val;
public:
  IfcElectricGeneratorTypeEnum() : m_val(kIfcElectricGeneratorTypeEnum_unset) {};
  IfcElectricGeneratorTypeEnum(const IfcElectricGeneratorTypeEnum &other) : m_val(other.m_val) {};
  IfcElectricGeneratorTypeEnum(IfcElectricGeneratorTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcElectricGeneratorTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcElectricGeneratorTypeEnum_unset; };
  operator IfcElectricGeneratorTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcElectricGeneratorTypeEnum& operator = (const IfcElectricGeneratorTypeEnum_ val) { if (val < kIfcElectricGeneratorTypeEnum_unset) m_val = val; else m_val = kIfcElectricGeneratorTypeEnum_unset; return *this; };
  bool operator == (const IfcElectricGeneratorTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcElectricGeneratorTypeEnum &in);
IfcElectricGeneratorTypeEnum StrToIfcElectricGeneratorTypeEnum(OdAnsiString val);
enum IfcElectricHeaterTypeEnum_
{
  kIfcElectricHeaterTypeEnum_ELECTRICPOINTHEATER,
  kIfcElectricHeaterTypeEnum_ELECTRICCABLEHEATER,
  kIfcElectricHeaterTypeEnum_ELECTRICMATHEATER,
  kIfcElectricHeaterTypeEnum_USERDEFINED,
  kIfcElectricHeaterTypeEnum_NOTDEFINED,
  kIfcElectricHeaterTypeEnum_unset
};
 
class IfcElectricHeaterTypeEnum {
  IfcElectricHeaterTypeEnum_ m_val;
public:
  IfcElectricHeaterTypeEnum() : m_val(kIfcElectricHeaterTypeEnum_unset) {};
  IfcElectricHeaterTypeEnum(const IfcElectricHeaterTypeEnum &other) : m_val(other.m_val) {};
  IfcElectricHeaterTypeEnum(IfcElectricHeaterTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcElectricHeaterTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcElectricHeaterTypeEnum_unset; };
  operator IfcElectricHeaterTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcElectricHeaterTypeEnum& operator = (const IfcElectricHeaterTypeEnum_ val) { if (val < kIfcElectricHeaterTypeEnum_unset) m_val = val; else m_val = kIfcElectricHeaterTypeEnum_unset; return *this; };
  bool operator == (const IfcElectricHeaterTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcElectricHeaterTypeEnum &in);
IfcElectricHeaterTypeEnum StrToIfcElectricHeaterTypeEnum(OdAnsiString val);
enum IfcElectricMotorTypeEnum_
{
  kIfcElectricMotorTypeEnum_DC,
  kIfcElectricMotorTypeEnum_INDUCTION,
  kIfcElectricMotorTypeEnum_POLYPHASE,
  kIfcElectricMotorTypeEnum_RELUCTANCESYNCHRONOUS,
  kIfcElectricMotorTypeEnum_SYNCHRONOUS,
  kIfcElectricMotorTypeEnum_USERDEFINED,
  kIfcElectricMotorTypeEnum_NOTDEFINED,
  kIfcElectricMotorTypeEnum_unset
};
 
class IfcElectricMotorTypeEnum {
  IfcElectricMotorTypeEnum_ m_val;
public:
  IfcElectricMotorTypeEnum() : m_val(kIfcElectricMotorTypeEnum_unset) {};
  IfcElectricMotorTypeEnum(const IfcElectricMotorTypeEnum &other) : m_val(other.m_val) {};
  IfcElectricMotorTypeEnum(IfcElectricMotorTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcElectricMotorTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcElectricMotorTypeEnum_unset; };
  operator IfcElectricMotorTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcElectricMotorTypeEnum& operator = (const IfcElectricMotorTypeEnum_ val) { if (val < kIfcElectricMotorTypeEnum_unset) m_val = val; else m_val = kIfcElectricMotorTypeEnum_unset; return *this; };
  bool operator == (const IfcElectricMotorTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcElectricMotorTypeEnum &in);
IfcElectricMotorTypeEnum StrToIfcElectricMotorTypeEnum(OdAnsiString val);
enum IfcElectricTimeControlTypeEnum_
{
  kIfcElectricTimeControlTypeEnum_TIMECLOCK,
  kIfcElectricTimeControlTypeEnum_TIMEDELAY,
  kIfcElectricTimeControlTypeEnum_RELAY,
  kIfcElectricTimeControlTypeEnum_USERDEFINED,
  kIfcElectricTimeControlTypeEnum_NOTDEFINED,
  kIfcElectricTimeControlTypeEnum_unset
};
 
class IfcElectricTimeControlTypeEnum {
  IfcElectricTimeControlTypeEnum_ m_val;
public:
  IfcElectricTimeControlTypeEnum() : m_val(kIfcElectricTimeControlTypeEnum_unset) {};
  IfcElectricTimeControlTypeEnum(const IfcElectricTimeControlTypeEnum &other) : m_val(other.m_val) {};
  IfcElectricTimeControlTypeEnum(IfcElectricTimeControlTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcElectricTimeControlTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcElectricTimeControlTypeEnum_unset; };
  operator IfcElectricTimeControlTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcElectricTimeControlTypeEnum& operator = (const IfcElectricTimeControlTypeEnum_ val) { if (val < kIfcElectricTimeControlTypeEnum_unset) m_val = val; else m_val = kIfcElectricTimeControlTypeEnum_unset; return *this; };
  bool operator == (const IfcElectricTimeControlTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcElectricTimeControlTypeEnum &in);
IfcElectricTimeControlTypeEnum StrToIfcElectricTimeControlTypeEnum(OdAnsiString val);
enum IfcElementAssemblyTypeEnum_
{
  kIfcElementAssemblyTypeEnum_ACCESSORY_ASSEMBLY,
  kIfcElementAssemblyTypeEnum_ARCH,
  kIfcElementAssemblyTypeEnum_BEAM_GRID,
  kIfcElementAssemblyTypeEnum_BRACED_FRAME,
  kIfcElementAssemblyTypeEnum_GIRDER,
  kIfcElementAssemblyTypeEnum_REINFORCEMENT_UNIT,
  kIfcElementAssemblyTypeEnum_RIGID_FRAME,
  kIfcElementAssemblyTypeEnum_SLAB_FIELD,
  kIfcElementAssemblyTypeEnum_TRUSS,
  kIfcElementAssemblyTypeEnum_USERDEFINED,
  kIfcElementAssemblyTypeEnum_NOTDEFINED,
  kIfcElementAssemblyTypeEnum_unset
};
 
class IfcElementAssemblyTypeEnum {
  IfcElementAssemblyTypeEnum_ m_val;
public:
  IfcElementAssemblyTypeEnum() : m_val(kIfcElementAssemblyTypeEnum_unset) {};
  IfcElementAssemblyTypeEnum(const IfcElementAssemblyTypeEnum &other) : m_val(other.m_val) {};
  IfcElementAssemblyTypeEnum(IfcElementAssemblyTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcElementAssemblyTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcElementAssemblyTypeEnum_unset; };
  operator IfcElementAssemblyTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcElementAssemblyTypeEnum& operator = (const IfcElementAssemblyTypeEnum_ val) { if (val < kIfcElementAssemblyTypeEnum_unset) m_val = val; else m_val = kIfcElementAssemblyTypeEnum_unset; return *this; };
  bool operator == (const IfcElementAssemblyTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcElementAssemblyTypeEnum &in);
IfcElementAssemblyTypeEnum StrToIfcElementAssemblyTypeEnum(OdAnsiString val);
enum IfcElementCompositionEnum_
{
  kIfcElementCompositionEnum_COMPLEX,
  kIfcElementCompositionEnum_ELEMENT,
  kIfcElementCompositionEnum_PARTIAL,
  kIfcElementCompositionEnum_unset
};
 
class IfcElementCompositionEnum {
  IfcElementCompositionEnum_ m_val;
public:
  IfcElementCompositionEnum() : m_val(kIfcElementCompositionEnum_unset) {};
  IfcElementCompositionEnum(const IfcElementCompositionEnum &other) : m_val(other.m_val) {};
  IfcElementCompositionEnum(IfcElementCompositionEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcElementCompositionEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcElementCompositionEnum_unset; };
  operator IfcElementCompositionEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcElementCompositionEnum& operator = (const IfcElementCompositionEnum_ val) { if (val < kIfcElementCompositionEnum_unset) m_val = val; else m_val = kIfcElementCompositionEnum_unset; return *this; };
  bool operator == (const IfcElementCompositionEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcElementCompositionEnum &in);
IfcElementCompositionEnum StrToIfcElementCompositionEnum(OdAnsiString val);
enum IfcEnergySequenceEnum_
{
  kIfcEnergySequenceEnum_PRIMARY,
  kIfcEnergySequenceEnum_SECONDARY,
  kIfcEnergySequenceEnum_TERTIARY,
  kIfcEnergySequenceEnum_AUXILIARY,
  kIfcEnergySequenceEnum_USERDEFINED,
  kIfcEnergySequenceEnum_NOTDEFINED,
  kIfcEnergySequenceEnum_unset
};
 
class IfcEnergySequenceEnum {
  IfcEnergySequenceEnum_ m_val;
public:
  IfcEnergySequenceEnum() : m_val(kIfcEnergySequenceEnum_unset) {};
  IfcEnergySequenceEnum(const IfcEnergySequenceEnum &other) : m_val(other.m_val) {};
  IfcEnergySequenceEnum(IfcEnergySequenceEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcEnergySequenceEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcEnergySequenceEnum_unset; };
  operator IfcEnergySequenceEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcEnergySequenceEnum& operator = (const IfcEnergySequenceEnum_ val) { if (val < kIfcEnergySequenceEnum_unset) m_val = val; else m_val = kIfcEnergySequenceEnum_unset; return *this; };
  bool operator == (const IfcEnergySequenceEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcEnergySequenceEnum &in);
IfcEnergySequenceEnum StrToIfcEnergySequenceEnum(OdAnsiString val);
enum IfcEnvironmentalImpactCategoryEnum_
{
  kIfcEnvironmentalImpactCategoryEnum_COMBINEDVALUE,
  kIfcEnvironmentalImpactCategoryEnum_DISPOSAL,
  kIfcEnvironmentalImpactCategoryEnum_EXTRACTION,
  kIfcEnvironmentalImpactCategoryEnum_INSTALLATION,
  kIfcEnvironmentalImpactCategoryEnum_MANUFACTURE,
  kIfcEnvironmentalImpactCategoryEnum_TRANSPORTATION,
  kIfcEnvironmentalImpactCategoryEnum_USERDEFINED,
  kIfcEnvironmentalImpactCategoryEnum_NOTDEFINED,
  kIfcEnvironmentalImpactCategoryEnum_unset
};
 
class IfcEnvironmentalImpactCategoryEnum {
  IfcEnvironmentalImpactCategoryEnum_ m_val;
public:
  IfcEnvironmentalImpactCategoryEnum() : m_val(kIfcEnvironmentalImpactCategoryEnum_unset) {};
  IfcEnvironmentalImpactCategoryEnum(const IfcEnvironmentalImpactCategoryEnum &other) : m_val(other.m_val) {};
  IfcEnvironmentalImpactCategoryEnum(IfcEnvironmentalImpactCategoryEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcEnvironmentalImpactCategoryEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcEnvironmentalImpactCategoryEnum_unset; };
  operator IfcEnvironmentalImpactCategoryEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcEnvironmentalImpactCategoryEnum& operator = (const IfcEnvironmentalImpactCategoryEnum_ val) { if (val < kIfcEnvironmentalImpactCategoryEnum_unset) m_val = val; else m_val = kIfcEnvironmentalImpactCategoryEnum_unset; return *this; };
  bool operator == (const IfcEnvironmentalImpactCategoryEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcEnvironmentalImpactCategoryEnum &in);
IfcEnvironmentalImpactCategoryEnum StrToIfcEnvironmentalImpactCategoryEnum(OdAnsiString val);
enum IfcEvaporativeCoolerTypeEnum_
{
  kIfcEvaporativeCoolerTypeEnum_DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER,
  kIfcEvaporativeCoolerTypeEnum_DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER,
  kIfcEvaporativeCoolerTypeEnum_DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER,
  kIfcEvaporativeCoolerTypeEnum_DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER,
  kIfcEvaporativeCoolerTypeEnum_DIRECTEVAPORATIVEAIRWASHER,
  kIfcEvaporativeCoolerTypeEnum_INDIRECTEVAPORATIVEPACKAGEAIRCOOLER,
  kIfcEvaporativeCoolerTypeEnum_INDIRECTEVAPORATIVEWETCOIL,
  kIfcEvaporativeCoolerTypeEnum_INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER,
  kIfcEvaporativeCoolerTypeEnum_INDIRECTDIRECTCOMBINATION,
  kIfcEvaporativeCoolerTypeEnum_USERDEFINED,
  kIfcEvaporativeCoolerTypeEnum_NOTDEFINED,
  kIfcEvaporativeCoolerTypeEnum_unset
};
 
class IfcEvaporativeCoolerTypeEnum {
  IfcEvaporativeCoolerTypeEnum_ m_val;
public:
  IfcEvaporativeCoolerTypeEnum() : m_val(kIfcEvaporativeCoolerTypeEnum_unset) {};
  IfcEvaporativeCoolerTypeEnum(const IfcEvaporativeCoolerTypeEnum &other) : m_val(other.m_val) {};
  IfcEvaporativeCoolerTypeEnum(IfcEvaporativeCoolerTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcEvaporativeCoolerTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcEvaporativeCoolerTypeEnum_unset; };
  operator IfcEvaporativeCoolerTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcEvaporativeCoolerTypeEnum& operator = (const IfcEvaporativeCoolerTypeEnum_ val) { if (val < kIfcEvaporativeCoolerTypeEnum_unset) m_val = val; else m_val = kIfcEvaporativeCoolerTypeEnum_unset; return *this; };
  bool operator == (const IfcEvaporativeCoolerTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcEvaporativeCoolerTypeEnum &in);
IfcEvaporativeCoolerTypeEnum StrToIfcEvaporativeCoolerTypeEnum(OdAnsiString val);
enum IfcEvaporatorTypeEnum_
{
  kIfcEvaporatorTypeEnum_DIRECTEXPANSIONSHELLANDTUBE,
  kIfcEvaporatorTypeEnum_DIRECTEXPANSIONTUBEINTUBE,
  kIfcEvaporatorTypeEnum_DIRECTEXPANSIONBRAZEDPLATE,
  kIfcEvaporatorTypeEnum_FLOODEDSHELLANDTUBE,
  kIfcEvaporatorTypeEnum_SHELLANDCOIL,
  kIfcEvaporatorTypeEnum_USERDEFINED,
  kIfcEvaporatorTypeEnum_NOTDEFINED,
  kIfcEvaporatorTypeEnum_unset
};
 
class IfcEvaporatorTypeEnum {
  IfcEvaporatorTypeEnum_ m_val;
public:
  IfcEvaporatorTypeEnum() : m_val(kIfcEvaporatorTypeEnum_unset) {};
  IfcEvaporatorTypeEnum(const IfcEvaporatorTypeEnum &other) : m_val(other.m_val) {};
  IfcEvaporatorTypeEnum(IfcEvaporatorTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcEvaporatorTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcEvaporatorTypeEnum_unset; };
  operator IfcEvaporatorTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcEvaporatorTypeEnum& operator = (const IfcEvaporatorTypeEnum_ val) { if (val < kIfcEvaporatorTypeEnum_unset) m_val = val; else m_val = kIfcEvaporatorTypeEnum_unset; return *this; };
  bool operator == (const IfcEvaporatorTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcEvaporatorTypeEnum &in);
IfcEvaporatorTypeEnum StrToIfcEvaporatorTypeEnum(OdAnsiString val);
enum IfcFanTypeEnum_
{
  kIfcFanTypeEnum_CENTRIFUGALFORWARDCURVED,
  kIfcFanTypeEnum_CENTRIFUGALRADIAL,
  kIfcFanTypeEnum_CENTRIFUGALBACKWARDINCLINEDCURVED,
  kIfcFanTypeEnum_CENTRIFUGALAIRFOIL,
  kIfcFanTypeEnum_TUBEAXIAL,
  kIfcFanTypeEnum_VANEAXIAL,
  kIfcFanTypeEnum_PROPELLORAXIAL,
  kIfcFanTypeEnum_USERDEFINED,
  kIfcFanTypeEnum_NOTDEFINED,
  kIfcFanTypeEnum_unset
};
 
class IfcFanTypeEnum {
  IfcFanTypeEnum_ m_val;
public:
  IfcFanTypeEnum() : m_val(kIfcFanTypeEnum_unset) {};
  IfcFanTypeEnum(const IfcFanTypeEnum &other) : m_val(other.m_val) {};
  IfcFanTypeEnum(IfcFanTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcFanTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcFanTypeEnum_unset; };
  operator IfcFanTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcFanTypeEnum& operator = (const IfcFanTypeEnum_ val) { if (val < kIfcFanTypeEnum_unset) m_val = val; else m_val = kIfcFanTypeEnum_unset; return *this; };
  bool operator == (const IfcFanTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcFanTypeEnum &in);
IfcFanTypeEnum StrToIfcFanTypeEnum(OdAnsiString val);
enum IfcFilterTypeEnum_
{
  kIfcFilterTypeEnum_AIRPARTICLEFILTER,
  kIfcFilterTypeEnum_ODORFILTER,
  kIfcFilterTypeEnum_OILFILTER,
  kIfcFilterTypeEnum_STRAINER,
  kIfcFilterTypeEnum_WATERFILTER,
  kIfcFilterTypeEnum_USERDEFINED,
  kIfcFilterTypeEnum_NOTDEFINED,
  kIfcFilterTypeEnum_unset
};
 
class IfcFilterTypeEnum {
  IfcFilterTypeEnum_ m_val;
public:
  IfcFilterTypeEnum() : m_val(kIfcFilterTypeEnum_unset) {};
  IfcFilterTypeEnum(const IfcFilterTypeEnum &other) : m_val(other.m_val) {};
  IfcFilterTypeEnum(IfcFilterTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcFilterTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcFilterTypeEnum_unset; };
  operator IfcFilterTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcFilterTypeEnum& operator = (const IfcFilterTypeEnum_ val) { if (val < kIfcFilterTypeEnum_unset) m_val = val; else m_val = kIfcFilterTypeEnum_unset; return *this; };
  bool operator == (const IfcFilterTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcFilterTypeEnum &in);
IfcFilterTypeEnum StrToIfcFilterTypeEnum(OdAnsiString val);
enum IfcFireSuppressionTerminalTypeEnum_
{
  kIfcFireSuppressionTerminalTypeEnum_BREECHINGINLET,
  kIfcFireSuppressionTerminalTypeEnum_FIREHYDRANT,
  kIfcFireSuppressionTerminalTypeEnum_HOSEREEL,
  kIfcFireSuppressionTerminalTypeEnum_SPRINKLER,
  kIfcFireSuppressionTerminalTypeEnum_SPRINKLERDEFLECTOR,
  kIfcFireSuppressionTerminalTypeEnum_USERDEFINED,
  kIfcFireSuppressionTerminalTypeEnum_NOTDEFINED,
  kIfcFireSuppressionTerminalTypeEnum_unset
};
 
class IfcFireSuppressionTerminalTypeEnum {
  IfcFireSuppressionTerminalTypeEnum_ m_val;
public:
  IfcFireSuppressionTerminalTypeEnum() : m_val(kIfcFireSuppressionTerminalTypeEnum_unset) {};
  IfcFireSuppressionTerminalTypeEnum(const IfcFireSuppressionTerminalTypeEnum &other) : m_val(other.m_val) {};
  IfcFireSuppressionTerminalTypeEnum(IfcFireSuppressionTerminalTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcFireSuppressionTerminalTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcFireSuppressionTerminalTypeEnum_unset; };
  operator IfcFireSuppressionTerminalTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcFireSuppressionTerminalTypeEnum& operator = (const IfcFireSuppressionTerminalTypeEnum_ val) { if (val < kIfcFireSuppressionTerminalTypeEnum_unset) m_val = val; else m_val = kIfcFireSuppressionTerminalTypeEnum_unset; return *this; };
  bool operator == (const IfcFireSuppressionTerminalTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcFireSuppressionTerminalTypeEnum &in);
IfcFireSuppressionTerminalTypeEnum StrToIfcFireSuppressionTerminalTypeEnum(OdAnsiString val);
enum IfcFlowDirectionEnum_
{
  kIfcFlowDirectionEnum_SOURCE,
  kIfcFlowDirectionEnum_SINK,
  kIfcFlowDirectionEnum_SOURCEANDSINK,
  kIfcFlowDirectionEnum_NOTDEFINED,
  kIfcFlowDirectionEnum_unset
};
 
class IfcFlowDirectionEnum {
  IfcFlowDirectionEnum_ m_val;
public:
  IfcFlowDirectionEnum() : m_val(kIfcFlowDirectionEnum_unset) {};
  IfcFlowDirectionEnum(const IfcFlowDirectionEnum &other) : m_val(other.m_val) {};
  IfcFlowDirectionEnum(IfcFlowDirectionEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcFlowDirectionEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcFlowDirectionEnum_unset; };
  operator IfcFlowDirectionEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcFlowDirectionEnum& operator = (const IfcFlowDirectionEnum_ val) { if (val < kIfcFlowDirectionEnum_unset) m_val = val; else m_val = kIfcFlowDirectionEnum_unset; return *this; };
  bool operator == (const IfcFlowDirectionEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcFlowDirectionEnum &in);
IfcFlowDirectionEnum StrToIfcFlowDirectionEnum(OdAnsiString val);
enum IfcFlowInstrumentTypeEnum_
{
  kIfcFlowInstrumentTypeEnum_PRESSUREGAUGE,
  kIfcFlowInstrumentTypeEnum_THERMOMETER,
  kIfcFlowInstrumentTypeEnum_AMMETER,
  kIfcFlowInstrumentTypeEnum_FREQUENCYMETER,
  kIfcFlowInstrumentTypeEnum_POWERFACTORMETER,
  kIfcFlowInstrumentTypeEnum_PHASEANGLEMETER,
  kIfcFlowInstrumentTypeEnum_VOLTMETER_PEAK,
  kIfcFlowInstrumentTypeEnum_VOLTMETER_RMS,
  kIfcFlowInstrumentTypeEnum_USERDEFINED,
  kIfcFlowInstrumentTypeEnum_NOTDEFINED,
  kIfcFlowInstrumentTypeEnum_unset
};
 
class IfcFlowInstrumentTypeEnum {
  IfcFlowInstrumentTypeEnum_ m_val;
public:
  IfcFlowInstrumentTypeEnum() : m_val(kIfcFlowInstrumentTypeEnum_unset) {};
  IfcFlowInstrumentTypeEnum(const IfcFlowInstrumentTypeEnum &other) : m_val(other.m_val) {};
  IfcFlowInstrumentTypeEnum(IfcFlowInstrumentTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcFlowInstrumentTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcFlowInstrumentTypeEnum_unset; };
  operator IfcFlowInstrumentTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcFlowInstrumentTypeEnum& operator = (const IfcFlowInstrumentTypeEnum_ val) { if (val < kIfcFlowInstrumentTypeEnum_unset) m_val = val; else m_val = kIfcFlowInstrumentTypeEnum_unset; return *this; };
  bool operator == (const IfcFlowInstrumentTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcFlowInstrumentTypeEnum &in);
IfcFlowInstrumentTypeEnum StrToIfcFlowInstrumentTypeEnum(OdAnsiString val);
enum IfcFlowMeterTypeEnum_
{
  kIfcFlowMeterTypeEnum_ELECTRICMETER,
  kIfcFlowMeterTypeEnum_ENERGYMETER,
  kIfcFlowMeterTypeEnum_FLOWMETER,
  kIfcFlowMeterTypeEnum_GASMETER,
  kIfcFlowMeterTypeEnum_OILMETER,
  kIfcFlowMeterTypeEnum_WATERMETER,
  kIfcFlowMeterTypeEnum_USERDEFINED,
  kIfcFlowMeterTypeEnum_NOTDEFINED,
  kIfcFlowMeterTypeEnum_unset
};
 
class IfcFlowMeterTypeEnum {
  IfcFlowMeterTypeEnum_ m_val;
public:
  IfcFlowMeterTypeEnum() : m_val(kIfcFlowMeterTypeEnum_unset) {};
  IfcFlowMeterTypeEnum(const IfcFlowMeterTypeEnum &other) : m_val(other.m_val) {};
  IfcFlowMeterTypeEnum(IfcFlowMeterTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcFlowMeterTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcFlowMeterTypeEnum_unset; };
  operator IfcFlowMeterTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcFlowMeterTypeEnum& operator = (const IfcFlowMeterTypeEnum_ val) { if (val < kIfcFlowMeterTypeEnum_unset) m_val = val; else m_val = kIfcFlowMeterTypeEnum_unset; return *this; };
  bool operator == (const IfcFlowMeterTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcFlowMeterTypeEnum &in);
IfcFlowMeterTypeEnum StrToIfcFlowMeterTypeEnum(OdAnsiString val);
enum IfcFootingTypeEnum_
{
  kIfcFootingTypeEnum_FOOTING_BEAM,
  kIfcFootingTypeEnum_PAD_FOOTING,
  kIfcFootingTypeEnum_PILE_CAP,
  kIfcFootingTypeEnum_STRIP_FOOTING,
  kIfcFootingTypeEnum_USERDEFINED,
  kIfcFootingTypeEnum_NOTDEFINED,
  kIfcFootingTypeEnum_unset
};
 
class IfcFootingTypeEnum {
  IfcFootingTypeEnum_ m_val;
public:
  IfcFootingTypeEnum() : m_val(kIfcFootingTypeEnum_unset) {};
  IfcFootingTypeEnum(const IfcFootingTypeEnum &other) : m_val(other.m_val) {};
  IfcFootingTypeEnum(IfcFootingTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcFootingTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcFootingTypeEnum_unset; };
  operator IfcFootingTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcFootingTypeEnum& operator = (const IfcFootingTypeEnum_ val) { if (val < kIfcFootingTypeEnum_unset) m_val = val; else m_val = kIfcFootingTypeEnum_unset; return *this; };
  bool operator == (const IfcFootingTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcFootingTypeEnum &in);
IfcFootingTypeEnum StrToIfcFootingTypeEnum(OdAnsiString val);
enum IfcGasTerminalTypeEnum_
{
  kIfcGasTerminalTypeEnum_GASAPPLIANCE,
  kIfcGasTerminalTypeEnum_GASBOOSTER,
  kIfcGasTerminalTypeEnum_GASBURNER,
  kIfcGasTerminalTypeEnum_USERDEFINED,
  kIfcGasTerminalTypeEnum_NOTDEFINED,
  kIfcGasTerminalTypeEnum_unset
};
 
class IfcGasTerminalTypeEnum {
  IfcGasTerminalTypeEnum_ m_val;
public:
  IfcGasTerminalTypeEnum() : m_val(kIfcGasTerminalTypeEnum_unset) {};
  IfcGasTerminalTypeEnum(const IfcGasTerminalTypeEnum &other) : m_val(other.m_val) {};
  IfcGasTerminalTypeEnum(IfcGasTerminalTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcGasTerminalTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcGasTerminalTypeEnum_unset; };
  operator IfcGasTerminalTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcGasTerminalTypeEnum& operator = (const IfcGasTerminalTypeEnum_ val) { if (val < kIfcGasTerminalTypeEnum_unset) m_val = val; else m_val = kIfcGasTerminalTypeEnum_unset; return *this; };
  bool operator == (const IfcGasTerminalTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcGasTerminalTypeEnum &in);
IfcGasTerminalTypeEnum StrToIfcGasTerminalTypeEnum(OdAnsiString val);
enum IfcGeometricProjectionEnum_
{
  kIfcGeometricProjectionEnum_GRAPH_VIEW,
  kIfcGeometricProjectionEnum_SKETCH_VIEW,
  kIfcGeometricProjectionEnum_MODEL_VIEW,
  kIfcGeometricProjectionEnum_PLAN_VIEW,
  kIfcGeometricProjectionEnum_REFLECTED_PLAN_VIEW,
  kIfcGeometricProjectionEnum_SECTION_VIEW,
  kIfcGeometricProjectionEnum_ELEVATION_VIEW,
  kIfcGeometricProjectionEnum_USERDEFINED,
  kIfcGeometricProjectionEnum_NOTDEFINED,
  kIfcGeometricProjectionEnum_unset
};
 
class IfcGeometricProjectionEnum {
  IfcGeometricProjectionEnum_ m_val;
public:
  IfcGeometricProjectionEnum() : m_val(kIfcGeometricProjectionEnum_unset) {};
  IfcGeometricProjectionEnum(const IfcGeometricProjectionEnum &other) : m_val(other.m_val) {};
  IfcGeometricProjectionEnum(IfcGeometricProjectionEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcGeometricProjectionEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcGeometricProjectionEnum_unset; };
  operator IfcGeometricProjectionEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcGeometricProjectionEnum& operator = (const IfcGeometricProjectionEnum_ val) { if (val < kIfcGeometricProjectionEnum_unset) m_val = val; else m_val = kIfcGeometricProjectionEnum_unset; return *this; };
  bool operator == (const IfcGeometricProjectionEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcGeometricProjectionEnum &in);
IfcGeometricProjectionEnum StrToIfcGeometricProjectionEnum(OdAnsiString val);
enum IfcGlobalOrLocalEnum_
{
  kIfcGlobalOrLocalEnum_GLOBAL_COORDS,
  kIfcGlobalOrLocalEnum_LOCAL_COORDS,
  kIfcGlobalOrLocalEnum_unset
};
 
class IfcGlobalOrLocalEnum {
  IfcGlobalOrLocalEnum_ m_val;
public:
  IfcGlobalOrLocalEnum() : m_val(kIfcGlobalOrLocalEnum_unset) {};
  IfcGlobalOrLocalEnum(const IfcGlobalOrLocalEnum &other) : m_val(other.m_val) {};
  IfcGlobalOrLocalEnum(IfcGlobalOrLocalEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcGlobalOrLocalEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcGlobalOrLocalEnum_unset; };
  operator IfcGlobalOrLocalEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcGlobalOrLocalEnum& operator = (const IfcGlobalOrLocalEnum_ val) { if (val < kIfcGlobalOrLocalEnum_unset) m_val = val; else m_val = kIfcGlobalOrLocalEnum_unset; return *this; };
  bool operator == (const IfcGlobalOrLocalEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcGlobalOrLocalEnum &in);
IfcGlobalOrLocalEnum StrToIfcGlobalOrLocalEnum(OdAnsiString val);
enum IfcHeatExchangerTypeEnum_
{
  kIfcHeatExchangerTypeEnum_PLATE,
  kIfcHeatExchangerTypeEnum_SHELLANDTUBE,
  kIfcHeatExchangerTypeEnum_USERDEFINED,
  kIfcHeatExchangerTypeEnum_NOTDEFINED,
  kIfcHeatExchangerTypeEnum_unset
};
 
class IfcHeatExchangerTypeEnum {
  IfcHeatExchangerTypeEnum_ m_val;
public:
  IfcHeatExchangerTypeEnum() : m_val(kIfcHeatExchangerTypeEnum_unset) {};
  IfcHeatExchangerTypeEnum(const IfcHeatExchangerTypeEnum &other) : m_val(other.m_val) {};
  IfcHeatExchangerTypeEnum(IfcHeatExchangerTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcHeatExchangerTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcHeatExchangerTypeEnum_unset; };
  operator IfcHeatExchangerTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcHeatExchangerTypeEnum& operator = (const IfcHeatExchangerTypeEnum_ val) { if (val < kIfcHeatExchangerTypeEnum_unset) m_val = val; else m_val = kIfcHeatExchangerTypeEnum_unset; return *this; };
  bool operator == (const IfcHeatExchangerTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcHeatExchangerTypeEnum &in);
IfcHeatExchangerTypeEnum StrToIfcHeatExchangerTypeEnum(OdAnsiString val);
enum IfcHumidifierTypeEnum_
{
  kIfcHumidifierTypeEnum_STEAMINJECTION,
  kIfcHumidifierTypeEnum_ADIABATICAIRWASHER,
  kIfcHumidifierTypeEnum_ADIABATICPAN,
  kIfcHumidifierTypeEnum_ADIABATICWETTEDELEMENT,
  kIfcHumidifierTypeEnum_ADIABATICATOMIZING,
  kIfcHumidifierTypeEnum_ADIABATICULTRASONIC,
  kIfcHumidifierTypeEnum_ADIABATICRIGIDMEDIA,
  kIfcHumidifierTypeEnum_ADIABATICCOMPRESSEDAIRNOZZLE,
  kIfcHumidifierTypeEnum_ASSISTEDELECTRIC,
  kIfcHumidifierTypeEnum_ASSISTEDNATURALGAS,
  kIfcHumidifierTypeEnum_ASSISTEDPROPANE,
  kIfcHumidifierTypeEnum_ASSISTEDBUTANE,
  kIfcHumidifierTypeEnum_ASSISTEDSTEAM,
  kIfcHumidifierTypeEnum_USERDEFINED,
  kIfcHumidifierTypeEnum_NOTDEFINED,
  kIfcHumidifierTypeEnum_unset
};
 
class IfcHumidifierTypeEnum {
  IfcHumidifierTypeEnum_ m_val;
public:
  IfcHumidifierTypeEnum() : m_val(kIfcHumidifierTypeEnum_unset) {};
  IfcHumidifierTypeEnum(const IfcHumidifierTypeEnum &other) : m_val(other.m_val) {};
  IfcHumidifierTypeEnum(IfcHumidifierTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcHumidifierTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcHumidifierTypeEnum_unset; };
  operator IfcHumidifierTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcHumidifierTypeEnum& operator = (const IfcHumidifierTypeEnum_ val) { if (val < kIfcHumidifierTypeEnum_unset) m_val = val; else m_val = kIfcHumidifierTypeEnum_unset; return *this; };
  bool operator == (const IfcHumidifierTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcHumidifierTypeEnum &in);
IfcHumidifierTypeEnum StrToIfcHumidifierTypeEnum(OdAnsiString val);
enum IfcInternalOrExternalEnum_
{
  kIfcInternalOrExternalEnum_INTERNAL,
  kIfcInternalOrExternalEnum_EXTERNAL,
  kIfcInternalOrExternalEnum_NOTDEFINED,
  kIfcInternalOrExternalEnum_unset
};
 
class IfcInternalOrExternalEnum {
  IfcInternalOrExternalEnum_ m_val;
public:
  IfcInternalOrExternalEnum() : m_val(kIfcInternalOrExternalEnum_unset) {};
  IfcInternalOrExternalEnum(const IfcInternalOrExternalEnum &other) : m_val(other.m_val) {};
  IfcInternalOrExternalEnum(IfcInternalOrExternalEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcInternalOrExternalEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcInternalOrExternalEnum_unset; };
  operator IfcInternalOrExternalEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcInternalOrExternalEnum& operator = (const IfcInternalOrExternalEnum_ val) { if (val < kIfcInternalOrExternalEnum_unset) m_val = val; else m_val = kIfcInternalOrExternalEnum_unset; return *this; };
  bool operator == (const IfcInternalOrExternalEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcInternalOrExternalEnum &in);
IfcInternalOrExternalEnum StrToIfcInternalOrExternalEnum(OdAnsiString val);
enum IfcInventoryTypeEnum_
{
  kIfcInventoryTypeEnum_ASSETINVENTORY,
  kIfcInventoryTypeEnum_SPACEINVENTORY,
  kIfcInventoryTypeEnum_FURNITUREINVENTORY,
  kIfcInventoryTypeEnum_USERDEFINED,
  kIfcInventoryTypeEnum_NOTDEFINED,
  kIfcInventoryTypeEnum_unset
};
 
class IfcInventoryTypeEnum {
  IfcInventoryTypeEnum_ m_val;
public:
  IfcInventoryTypeEnum() : m_val(kIfcInventoryTypeEnum_unset) {};
  IfcInventoryTypeEnum(const IfcInventoryTypeEnum &other) : m_val(other.m_val) {};
  IfcInventoryTypeEnum(IfcInventoryTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcInventoryTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcInventoryTypeEnum_unset; };
  operator IfcInventoryTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcInventoryTypeEnum& operator = (const IfcInventoryTypeEnum_ val) { if (val < kIfcInventoryTypeEnum_unset) m_val = val; else m_val = kIfcInventoryTypeEnum_unset; return *this; };
  bool operator == (const IfcInventoryTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcInventoryTypeEnum &in);
IfcInventoryTypeEnum StrToIfcInventoryTypeEnum(OdAnsiString val);
enum IfcJunctionBoxTypeEnum_
{
  kIfcJunctionBoxTypeEnum_USERDEFINED,
  kIfcJunctionBoxTypeEnum_NOTDEFINED,
  kIfcJunctionBoxTypeEnum_unset
};
 
class IfcJunctionBoxTypeEnum {
  IfcJunctionBoxTypeEnum_ m_val;
public:
  IfcJunctionBoxTypeEnum() : m_val(kIfcJunctionBoxTypeEnum_unset) {};
  IfcJunctionBoxTypeEnum(const IfcJunctionBoxTypeEnum &other) : m_val(other.m_val) {};
  IfcJunctionBoxTypeEnum(IfcJunctionBoxTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcJunctionBoxTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcJunctionBoxTypeEnum_unset; };
  operator IfcJunctionBoxTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcJunctionBoxTypeEnum& operator = (const IfcJunctionBoxTypeEnum_ val) { if (val < kIfcJunctionBoxTypeEnum_unset) m_val = val; else m_val = kIfcJunctionBoxTypeEnum_unset; return *this; };
  bool operator == (const IfcJunctionBoxTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcJunctionBoxTypeEnum &in);
IfcJunctionBoxTypeEnum StrToIfcJunctionBoxTypeEnum(OdAnsiString val);
enum IfcLampTypeEnum_
{
  kIfcLampTypeEnum_COMPACTFLUORESCENT,
  kIfcLampTypeEnum_FLUORESCENT,
  kIfcLampTypeEnum_HIGHPRESSUREMERCURY,
  kIfcLampTypeEnum_HIGHPRESSURESODIUM,
  kIfcLampTypeEnum_METALHALIDE,
  kIfcLampTypeEnum_TUNGSTENFILAMENT,
  kIfcLampTypeEnum_USERDEFINED,
  kIfcLampTypeEnum_NOTDEFINED,
  kIfcLampTypeEnum_unset
};
 
class IfcLampTypeEnum {
  IfcLampTypeEnum_ m_val;
public:
  IfcLampTypeEnum() : m_val(kIfcLampTypeEnum_unset) {};
  IfcLampTypeEnum(const IfcLampTypeEnum &other) : m_val(other.m_val) {};
  IfcLampTypeEnum(IfcLampTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcLampTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcLampTypeEnum_unset; };
  operator IfcLampTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcLampTypeEnum& operator = (const IfcLampTypeEnum_ val) { if (val < kIfcLampTypeEnum_unset) m_val = val; else m_val = kIfcLampTypeEnum_unset; return *this; };
  bool operator == (const IfcLampTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcLampTypeEnum &in);
IfcLampTypeEnum StrToIfcLampTypeEnum(OdAnsiString val);
enum IfcLayerSetDirectionEnum_
{
  kIfcLayerSetDirectionEnum_AXIS1,
  kIfcLayerSetDirectionEnum_AXIS2,
  kIfcLayerSetDirectionEnum_AXIS3,
  kIfcLayerSetDirectionEnum_unset
};
 
class IfcLayerSetDirectionEnum {
  IfcLayerSetDirectionEnum_ m_val;
public:
  IfcLayerSetDirectionEnum() : m_val(kIfcLayerSetDirectionEnum_unset) {};
  IfcLayerSetDirectionEnum(const IfcLayerSetDirectionEnum &other) : m_val(other.m_val) {};
  IfcLayerSetDirectionEnum(IfcLayerSetDirectionEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcLayerSetDirectionEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcLayerSetDirectionEnum_unset; };
  operator IfcLayerSetDirectionEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcLayerSetDirectionEnum& operator = (const IfcLayerSetDirectionEnum_ val) { if (val < kIfcLayerSetDirectionEnum_unset) m_val = val; else m_val = kIfcLayerSetDirectionEnum_unset; return *this; };
  bool operator == (const IfcLayerSetDirectionEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcLayerSetDirectionEnum &in);
IfcLayerSetDirectionEnum StrToIfcLayerSetDirectionEnum(OdAnsiString val);
enum IfcLightDistributionCurveEnum_
{
  kIfcLightDistributionCurveEnum_TYPE_A,
  kIfcLightDistributionCurveEnum_TYPE_B,
  kIfcLightDistributionCurveEnum_TYPE_C,
  kIfcLightDistributionCurveEnum_NOTDEFINED,
  kIfcLightDistributionCurveEnum_unset
};
 
class IfcLightDistributionCurveEnum {
  IfcLightDistributionCurveEnum_ m_val;
public:
  IfcLightDistributionCurveEnum() : m_val(kIfcLightDistributionCurveEnum_unset) {};
  IfcLightDistributionCurveEnum(const IfcLightDistributionCurveEnum &other) : m_val(other.m_val) {};
  IfcLightDistributionCurveEnum(IfcLightDistributionCurveEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcLightDistributionCurveEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcLightDistributionCurveEnum_unset; };
  operator IfcLightDistributionCurveEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcLightDistributionCurveEnum& operator = (const IfcLightDistributionCurveEnum_ val) { if (val < kIfcLightDistributionCurveEnum_unset) m_val = val; else m_val = kIfcLightDistributionCurveEnum_unset; return *this; };
  bool operator == (const IfcLightDistributionCurveEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcLightDistributionCurveEnum &in);
IfcLightDistributionCurveEnum StrToIfcLightDistributionCurveEnum(OdAnsiString val);
enum IfcLightEmissionSourceEnum_
{
  kIfcLightEmissionSourceEnum_COMPACTFLUORESCENT,
  kIfcLightEmissionSourceEnum_FLUORESCENT,
  kIfcLightEmissionSourceEnum_HIGHPRESSUREMERCURY,
  kIfcLightEmissionSourceEnum_HIGHPRESSURESODIUM,
  kIfcLightEmissionSourceEnum_LIGHTEMITTINGDIODE,
  kIfcLightEmissionSourceEnum_LOWPRESSURESODIUM,
  kIfcLightEmissionSourceEnum_LOWVOLTAGEHALOGEN,
  kIfcLightEmissionSourceEnum_MAINVOLTAGEHALOGEN,
  kIfcLightEmissionSourceEnum_METALHALIDE,
  kIfcLightEmissionSourceEnum_TUNGSTENFILAMENT,
  kIfcLightEmissionSourceEnum_NOTDEFINED,
  kIfcLightEmissionSourceEnum_unset
};
 
class IfcLightEmissionSourceEnum {
  IfcLightEmissionSourceEnum_ m_val;
public:
  IfcLightEmissionSourceEnum() : m_val(kIfcLightEmissionSourceEnum_unset) {};
  IfcLightEmissionSourceEnum(const IfcLightEmissionSourceEnum &other) : m_val(other.m_val) {};
  IfcLightEmissionSourceEnum(IfcLightEmissionSourceEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcLightEmissionSourceEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcLightEmissionSourceEnum_unset; };
  operator IfcLightEmissionSourceEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcLightEmissionSourceEnum& operator = (const IfcLightEmissionSourceEnum_ val) { if (val < kIfcLightEmissionSourceEnum_unset) m_val = val; else m_val = kIfcLightEmissionSourceEnum_unset; return *this; };
  bool operator == (const IfcLightEmissionSourceEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcLightEmissionSourceEnum &in);
IfcLightEmissionSourceEnum StrToIfcLightEmissionSourceEnum(OdAnsiString val);
enum IfcLightFixtureTypeEnum_
{
  kIfcLightFixtureTypeEnum_POINTSOURCE,
  kIfcLightFixtureTypeEnum_DIRECTIONSOURCE,
  kIfcLightFixtureTypeEnum_USERDEFINED,
  kIfcLightFixtureTypeEnum_NOTDEFINED,
  kIfcLightFixtureTypeEnum_unset
};
 
class IfcLightFixtureTypeEnum {
  IfcLightFixtureTypeEnum_ m_val;
public:
  IfcLightFixtureTypeEnum() : m_val(kIfcLightFixtureTypeEnum_unset) {};
  IfcLightFixtureTypeEnum(const IfcLightFixtureTypeEnum &other) : m_val(other.m_val) {};
  IfcLightFixtureTypeEnum(IfcLightFixtureTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcLightFixtureTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcLightFixtureTypeEnum_unset; };
  operator IfcLightFixtureTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcLightFixtureTypeEnum& operator = (const IfcLightFixtureTypeEnum_ val) { if (val < kIfcLightFixtureTypeEnum_unset) m_val = val; else m_val = kIfcLightFixtureTypeEnum_unset; return *this; };
  bool operator == (const IfcLightFixtureTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcLightFixtureTypeEnum &in);
IfcLightFixtureTypeEnum StrToIfcLightFixtureTypeEnum(OdAnsiString val);
enum IfcLoadGroupTypeEnum_
{
  kIfcLoadGroupTypeEnum_LOAD_GROUP,
  kIfcLoadGroupTypeEnum_LOAD_CASE,
  kIfcLoadGroupTypeEnum_LOAD_COMBINATION_GROUP,
  kIfcLoadGroupTypeEnum_LOAD_COMBINATION,
  kIfcLoadGroupTypeEnum_USERDEFINED,
  kIfcLoadGroupTypeEnum_NOTDEFINED,
  kIfcLoadGroupTypeEnum_unset
};
 
class IfcLoadGroupTypeEnum {
  IfcLoadGroupTypeEnum_ m_val;
public:
  IfcLoadGroupTypeEnum() : m_val(kIfcLoadGroupTypeEnum_unset) {};
  IfcLoadGroupTypeEnum(const IfcLoadGroupTypeEnum &other) : m_val(other.m_val) {};
  IfcLoadGroupTypeEnum(IfcLoadGroupTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcLoadGroupTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcLoadGroupTypeEnum_unset; };
  operator IfcLoadGroupTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcLoadGroupTypeEnum& operator = (const IfcLoadGroupTypeEnum_ val) { if (val < kIfcLoadGroupTypeEnum_unset) m_val = val; else m_val = kIfcLoadGroupTypeEnum_unset; return *this; };
  bool operator == (const IfcLoadGroupTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcLoadGroupTypeEnum &in);
IfcLoadGroupTypeEnum StrToIfcLoadGroupTypeEnum(OdAnsiString val);
enum IfcLogicalOperatorEnum_
{
  kIfcLogicalOperatorEnum_LOGICALAND,
  kIfcLogicalOperatorEnum_LOGICALOR,
  kIfcLogicalOperatorEnum_unset
};
 
class IfcLogicalOperatorEnum {
  IfcLogicalOperatorEnum_ m_val;
public:
  IfcLogicalOperatorEnum() : m_val(kIfcLogicalOperatorEnum_unset) {};
  IfcLogicalOperatorEnum(const IfcLogicalOperatorEnum &other) : m_val(other.m_val) {};
  IfcLogicalOperatorEnum(IfcLogicalOperatorEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcLogicalOperatorEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcLogicalOperatorEnum_unset; };
  operator IfcLogicalOperatorEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcLogicalOperatorEnum& operator = (const IfcLogicalOperatorEnum_ val) { if (val < kIfcLogicalOperatorEnum_unset) m_val = val; else m_val = kIfcLogicalOperatorEnum_unset; return *this; };
  bool operator == (const IfcLogicalOperatorEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcLogicalOperatorEnum &in);
IfcLogicalOperatorEnum StrToIfcLogicalOperatorEnum(OdAnsiString val);
enum IfcMemberTypeEnum_
{
  kIfcMemberTypeEnum_BRACE,
  kIfcMemberTypeEnum_CHORD,
  kIfcMemberTypeEnum_COLLAR,
  kIfcMemberTypeEnum_MEMBER,
  kIfcMemberTypeEnum_MULLION,
  kIfcMemberTypeEnum_PLATE,
  kIfcMemberTypeEnum_POST,
  kIfcMemberTypeEnum_PURLIN,
  kIfcMemberTypeEnum_RAFTER,
  kIfcMemberTypeEnum_STRINGER,
  kIfcMemberTypeEnum_STRUT,
  kIfcMemberTypeEnum_STUD,
  kIfcMemberTypeEnum_USERDEFINED,
  kIfcMemberTypeEnum_NOTDEFINED,
  kIfcMemberTypeEnum_unset
};
 
class IfcMemberTypeEnum {
  IfcMemberTypeEnum_ m_val;
public:
  IfcMemberTypeEnum() : m_val(kIfcMemberTypeEnum_unset) {};
  IfcMemberTypeEnum(const IfcMemberTypeEnum &other) : m_val(other.m_val) {};
  IfcMemberTypeEnum(IfcMemberTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcMemberTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcMemberTypeEnum_unset; };
  operator IfcMemberTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcMemberTypeEnum& operator = (const IfcMemberTypeEnum_ val) { if (val < kIfcMemberTypeEnum_unset) m_val = val; else m_val = kIfcMemberTypeEnum_unset; return *this; };
  bool operator == (const IfcMemberTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcMemberTypeEnum &in);
IfcMemberTypeEnum StrToIfcMemberTypeEnum(OdAnsiString val);
enum IfcMotorConnectionTypeEnum_
{
  kIfcMotorConnectionTypeEnum_BELTDRIVE,
  kIfcMotorConnectionTypeEnum_COUPLING,
  kIfcMotorConnectionTypeEnum_DIRECTDRIVE,
  kIfcMotorConnectionTypeEnum_USERDEFINED,
  kIfcMotorConnectionTypeEnum_NOTDEFINED,
  kIfcMotorConnectionTypeEnum_unset
};
 
class IfcMotorConnectionTypeEnum {
  IfcMotorConnectionTypeEnum_ m_val;
public:
  IfcMotorConnectionTypeEnum() : m_val(kIfcMotorConnectionTypeEnum_unset) {};
  IfcMotorConnectionTypeEnum(const IfcMotorConnectionTypeEnum &other) : m_val(other.m_val) {};
  IfcMotorConnectionTypeEnum(IfcMotorConnectionTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcMotorConnectionTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcMotorConnectionTypeEnum_unset; };
  operator IfcMotorConnectionTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcMotorConnectionTypeEnum& operator = (const IfcMotorConnectionTypeEnum_ val) { if (val < kIfcMotorConnectionTypeEnum_unset) m_val = val; else m_val = kIfcMotorConnectionTypeEnum_unset; return *this; };
  bool operator == (const IfcMotorConnectionTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcMotorConnectionTypeEnum &in);
IfcMotorConnectionTypeEnum StrToIfcMotorConnectionTypeEnum(OdAnsiString val);
enum IfcNullStyle_
{
  kIfcNullStyle_NULL,
  kIfcNullStyle_unset
};
 
class IfcNullStyle {
  IfcNullStyle_ m_val;
public:
  IfcNullStyle() : m_val(kIfcNullStyle_unset) {};
  IfcNullStyle(const IfcNullStyle &other) : m_val(other.m_val) {};
  IfcNullStyle(IfcNullStyle_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcNullStyle_unset ? 1 : 0; };
  void nullify() { m_val = kIfcNullStyle_unset; };
  operator IfcNullStyle_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcNullStyle& operator = (const IfcNullStyle_ val) { if (val < kIfcNullStyle_unset) m_val = val; else m_val = kIfcNullStyle_unset; return *this; };
  bool operator == (const IfcNullStyle &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcNullStyle &in);
IfcNullStyle StrToIfcNullStyle(OdAnsiString val);
enum IfcObjectTypeEnum_
{
  kIfcObjectTypeEnum_PRODUCT,
  kIfcObjectTypeEnum_PROCESS,
  kIfcObjectTypeEnum_CONTROL,
  kIfcObjectTypeEnum_RESOURCE,
  kIfcObjectTypeEnum_ACTOR,
  kIfcObjectTypeEnum_GROUP,
  kIfcObjectTypeEnum_PROJECT,
  kIfcObjectTypeEnum_NOTDEFINED,
  kIfcObjectTypeEnum_unset
};
 
class IfcObjectTypeEnum {
  IfcObjectTypeEnum_ m_val;
public:
  IfcObjectTypeEnum() : m_val(kIfcObjectTypeEnum_unset) {};
  IfcObjectTypeEnum(const IfcObjectTypeEnum &other) : m_val(other.m_val) {};
  IfcObjectTypeEnum(IfcObjectTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcObjectTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcObjectTypeEnum_unset; };
  operator IfcObjectTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcObjectTypeEnum& operator = (const IfcObjectTypeEnum_ val) { if (val < kIfcObjectTypeEnum_unset) m_val = val; else m_val = kIfcObjectTypeEnum_unset; return *this; };
  bool operator == (const IfcObjectTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcObjectTypeEnum &in);
IfcObjectTypeEnum StrToIfcObjectTypeEnum(OdAnsiString val);
enum IfcObjectiveEnum_
{
  kIfcObjectiveEnum_CODECOMPLIANCE,
  kIfcObjectiveEnum_DESIGNINTENT,
  kIfcObjectiveEnum_HEALTHANDSAFETY,
  kIfcObjectiveEnum_REQUIREMENT,
  kIfcObjectiveEnum_SPECIFICATION,
  kIfcObjectiveEnum_TRIGGERCONDITION,
  kIfcObjectiveEnum_USERDEFINED,
  kIfcObjectiveEnum_NOTDEFINED,
  kIfcObjectiveEnum_unset
};
 
class IfcObjectiveEnum {
  IfcObjectiveEnum_ m_val;
public:
  IfcObjectiveEnum() : m_val(kIfcObjectiveEnum_unset) {};
  IfcObjectiveEnum(const IfcObjectiveEnum &other) : m_val(other.m_val) {};
  IfcObjectiveEnum(IfcObjectiveEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcObjectiveEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcObjectiveEnum_unset; };
  operator IfcObjectiveEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcObjectiveEnum& operator = (const IfcObjectiveEnum_ val) { if (val < kIfcObjectiveEnum_unset) m_val = val; else m_val = kIfcObjectiveEnum_unset; return *this; };
  bool operator == (const IfcObjectiveEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcObjectiveEnum &in);
IfcObjectiveEnum StrToIfcObjectiveEnum(OdAnsiString val);
enum IfcOccupantTypeEnum_
{
  kIfcOccupantTypeEnum_ASSIGNEE,
  kIfcOccupantTypeEnum_ASSIGNOR,
  kIfcOccupantTypeEnum_LESSEE,
  kIfcOccupantTypeEnum_LESSOR,
  kIfcOccupantTypeEnum_LETTINGAGENT,
  kIfcOccupantTypeEnum_OWNER,
  kIfcOccupantTypeEnum_TENANT,
  kIfcOccupantTypeEnum_USERDEFINED,
  kIfcOccupantTypeEnum_NOTDEFINED,
  kIfcOccupantTypeEnum_unset
};
 
class IfcOccupantTypeEnum {
  IfcOccupantTypeEnum_ m_val;
public:
  IfcOccupantTypeEnum() : m_val(kIfcOccupantTypeEnum_unset) {};
  IfcOccupantTypeEnum(const IfcOccupantTypeEnum &other) : m_val(other.m_val) {};
  IfcOccupantTypeEnum(IfcOccupantTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcOccupantTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcOccupantTypeEnum_unset; };
  operator IfcOccupantTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcOccupantTypeEnum& operator = (const IfcOccupantTypeEnum_ val) { if (val < kIfcOccupantTypeEnum_unset) m_val = val; else m_val = kIfcOccupantTypeEnum_unset; return *this; };
  bool operator == (const IfcOccupantTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcOccupantTypeEnum &in);
IfcOccupantTypeEnum StrToIfcOccupantTypeEnum(OdAnsiString val);
enum IfcOutletTypeEnum_
{
  kIfcOutletTypeEnum_AUDIOVISUALOUTLET,
  kIfcOutletTypeEnum_COMMUNICATIONSOUTLET,
  kIfcOutletTypeEnum_POWEROUTLET,
  kIfcOutletTypeEnum_USERDEFINED,
  kIfcOutletTypeEnum_NOTDEFINED,
  kIfcOutletTypeEnum_unset
};
 
class IfcOutletTypeEnum {
  IfcOutletTypeEnum_ m_val;
public:
  IfcOutletTypeEnum() : m_val(kIfcOutletTypeEnum_unset) {};
  IfcOutletTypeEnum(const IfcOutletTypeEnum &other) : m_val(other.m_val) {};
  IfcOutletTypeEnum(IfcOutletTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcOutletTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcOutletTypeEnum_unset; };
  operator IfcOutletTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcOutletTypeEnum& operator = (const IfcOutletTypeEnum_ val) { if (val < kIfcOutletTypeEnum_unset) m_val = val; else m_val = kIfcOutletTypeEnum_unset; return *this; };
  bool operator == (const IfcOutletTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcOutletTypeEnum &in);
IfcOutletTypeEnum StrToIfcOutletTypeEnum(OdAnsiString val);
enum IfcPermeableCoveringOperationEnum_
{
  kIfcPermeableCoveringOperationEnum_GRILL,
  kIfcPermeableCoveringOperationEnum_LOUVER,
  kIfcPermeableCoveringOperationEnum_SCREEN,
  kIfcPermeableCoveringOperationEnum_USERDEFINED,
  kIfcPermeableCoveringOperationEnum_NOTDEFINED,
  kIfcPermeableCoveringOperationEnum_unset
};
 
class IfcPermeableCoveringOperationEnum {
  IfcPermeableCoveringOperationEnum_ m_val;
public:
  IfcPermeableCoveringOperationEnum() : m_val(kIfcPermeableCoveringOperationEnum_unset) {};
  IfcPermeableCoveringOperationEnum(const IfcPermeableCoveringOperationEnum &other) : m_val(other.m_val) {};
  IfcPermeableCoveringOperationEnum(IfcPermeableCoveringOperationEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcPermeableCoveringOperationEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcPermeableCoveringOperationEnum_unset; };
  operator IfcPermeableCoveringOperationEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcPermeableCoveringOperationEnum& operator = (const IfcPermeableCoveringOperationEnum_ val) { if (val < kIfcPermeableCoveringOperationEnum_unset) m_val = val; else m_val = kIfcPermeableCoveringOperationEnum_unset; return *this; };
  bool operator == (const IfcPermeableCoveringOperationEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcPermeableCoveringOperationEnum &in);
IfcPermeableCoveringOperationEnum StrToIfcPermeableCoveringOperationEnum(OdAnsiString val);
enum IfcPhysicalOrVirtualEnum_
{
  kIfcPhysicalOrVirtualEnum_PHYSICAL,
  kIfcPhysicalOrVirtualEnum_VIRTUAL,
  kIfcPhysicalOrVirtualEnum_NOTDEFINED,
  kIfcPhysicalOrVirtualEnum_unset
};
 
class IfcPhysicalOrVirtualEnum {
  IfcPhysicalOrVirtualEnum_ m_val;
public:
  IfcPhysicalOrVirtualEnum() : m_val(kIfcPhysicalOrVirtualEnum_unset) {};
  IfcPhysicalOrVirtualEnum(const IfcPhysicalOrVirtualEnum &other) : m_val(other.m_val) {};
  IfcPhysicalOrVirtualEnum(IfcPhysicalOrVirtualEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcPhysicalOrVirtualEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcPhysicalOrVirtualEnum_unset; };
  operator IfcPhysicalOrVirtualEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcPhysicalOrVirtualEnum& operator = (const IfcPhysicalOrVirtualEnum_ val) { if (val < kIfcPhysicalOrVirtualEnum_unset) m_val = val; else m_val = kIfcPhysicalOrVirtualEnum_unset; return *this; };
  bool operator == (const IfcPhysicalOrVirtualEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcPhysicalOrVirtualEnum &in);
IfcPhysicalOrVirtualEnum StrToIfcPhysicalOrVirtualEnum(OdAnsiString val);
enum IfcPileConstructionEnum_
{
  kIfcPileConstructionEnum_CAST_IN_PLACE,
  kIfcPileConstructionEnum_COMPOSITE,
  kIfcPileConstructionEnum_PRECAST_CONCRETE,
  kIfcPileConstructionEnum_PREFAB_STEEL,
  kIfcPileConstructionEnum_USERDEFINED,
  kIfcPileConstructionEnum_NOTDEFINED,
  kIfcPileConstructionEnum_unset
};
 
class IfcPileConstructionEnum {
  IfcPileConstructionEnum_ m_val;
public:
  IfcPileConstructionEnum() : m_val(kIfcPileConstructionEnum_unset) {};
  IfcPileConstructionEnum(const IfcPileConstructionEnum &other) : m_val(other.m_val) {};
  IfcPileConstructionEnum(IfcPileConstructionEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcPileConstructionEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcPileConstructionEnum_unset; };
  operator IfcPileConstructionEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcPileConstructionEnum& operator = (const IfcPileConstructionEnum_ val) { if (val < kIfcPileConstructionEnum_unset) m_val = val; else m_val = kIfcPileConstructionEnum_unset; return *this; };
  bool operator == (const IfcPileConstructionEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcPileConstructionEnum &in);
IfcPileConstructionEnum StrToIfcPileConstructionEnum(OdAnsiString val);
enum IfcPileTypeEnum_
{
  kIfcPileTypeEnum_COHESION,
  kIfcPileTypeEnum_FRICTION,
  kIfcPileTypeEnum_SUPPORT,
  kIfcPileTypeEnum_USERDEFINED,
  kIfcPileTypeEnum_NOTDEFINED,
  kIfcPileTypeEnum_unset
};
 
class IfcPileTypeEnum {
  IfcPileTypeEnum_ m_val;
public:
  IfcPileTypeEnum() : m_val(kIfcPileTypeEnum_unset) {};
  IfcPileTypeEnum(const IfcPileTypeEnum &other) : m_val(other.m_val) {};
  IfcPileTypeEnum(IfcPileTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcPileTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcPileTypeEnum_unset; };
  operator IfcPileTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcPileTypeEnum& operator = (const IfcPileTypeEnum_ val) { if (val < kIfcPileTypeEnum_unset) m_val = val; else m_val = kIfcPileTypeEnum_unset; return *this; };
  bool operator == (const IfcPileTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcPileTypeEnum &in);
IfcPileTypeEnum StrToIfcPileTypeEnum(OdAnsiString val);
enum IfcPipeFittingTypeEnum_
{
  kIfcPipeFittingTypeEnum_BEND,
  kIfcPipeFittingTypeEnum_CONNECTOR,
  kIfcPipeFittingTypeEnum_ENTRY,
  kIfcPipeFittingTypeEnum_EXIT,
  kIfcPipeFittingTypeEnum_JUNCTION,
  kIfcPipeFittingTypeEnum_OBSTRUCTION,
  kIfcPipeFittingTypeEnum_TRANSITION,
  kIfcPipeFittingTypeEnum_USERDEFINED,
  kIfcPipeFittingTypeEnum_NOTDEFINED,
  kIfcPipeFittingTypeEnum_unset
};
 
class IfcPipeFittingTypeEnum {
  IfcPipeFittingTypeEnum_ m_val;
public:
  IfcPipeFittingTypeEnum() : m_val(kIfcPipeFittingTypeEnum_unset) {};
  IfcPipeFittingTypeEnum(const IfcPipeFittingTypeEnum &other) : m_val(other.m_val) {};
  IfcPipeFittingTypeEnum(IfcPipeFittingTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcPipeFittingTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcPipeFittingTypeEnum_unset; };
  operator IfcPipeFittingTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcPipeFittingTypeEnum& operator = (const IfcPipeFittingTypeEnum_ val) { if (val < kIfcPipeFittingTypeEnum_unset) m_val = val; else m_val = kIfcPipeFittingTypeEnum_unset; return *this; };
  bool operator == (const IfcPipeFittingTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcPipeFittingTypeEnum &in);
IfcPipeFittingTypeEnum StrToIfcPipeFittingTypeEnum(OdAnsiString val);
enum IfcPipeSegmentTypeEnum_
{
  kIfcPipeSegmentTypeEnum_FLEXIBLESEGMENT,
  kIfcPipeSegmentTypeEnum_RIGIDSEGMENT,
  kIfcPipeSegmentTypeEnum_GUTTER,
  kIfcPipeSegmentTypeEnum_SPOOL,
  kIfcPipeSegmentTypeEnum_USERDEFINED,
  kIfcPipeSegmentTypeEnum_NOTDEFINED,
  kIfcPipeSegmentTypeEnum_unset
};
 
class IfcPipeSegmentTypeEnum {
  IfcPipeSegmentTypeEnum_ m_val;
public:
  IfcPipeSegmentTypeEnum() : m_val(kIfcPipeSegmentTypeEnum_unset) {};
  IfcPipeSegmentTypeEnum(const IfcPipeSegmentTypeEnum &other) : m_val(other.m_val) {};
  IfcPipeSegmentTypeEnum(IfcPipeSegmentTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcPipeSegmentTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcPipeSegmentTypeEnum_unset; };
  operator IfcPipeSegmentTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcPipeSegmentTypeEnum& operator = (const IfcPipeSegmentTypeEnum_ val) { if (val < kIfcPipeSegmentTypeEnum_unset) m_val = val; else m_val = kIfcPipeSegmentTypeEnum_unset; return *this; };
  bool operator == (const IfcPipeSegmentTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcPipeSegmentTypeEnum &in);
IfcPipeSegmentTypeEnum StrToIfcPipeSegmentTypeEnum(OdAnsiString val);
enum IfcPlateTypeEnum_
{
  kIfcPlateTypeEnum_CURTAIN_PANEL,
  kIfcPlateTypeEnum_SHEET,
  kIfcPlateTypeEnum_USERDEFINED,
  kIfcPlateTypeEnum_NOTDEFINED,
  kIfcPlateTypeEnum_unset
};
 
class IfcPlateTypeEnum {
  IfcPlateTypeEnum_ m_val;
public:
  IfcPlateTypeEnum() : m_val(kIfcPlateTypeEnum_unset) {};
  IfcPlateTypeEnum(const IfcPlateTypeEnum &other) : m_val(other.m_val) {};
  IfcPlateTypeEnum(IfcPlateTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcPlateTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcPlateTypeEnum_unset; };
  operator IfcPlateTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcPlateTypeEnum& operator = (const IfcPlateTypeEnum_ val) { if (val < kIfcPlateTypeEnum_unset) m_val = val; else m_val = kIfcPlateTypeEnum_unset; return *this; };
  bool operator == (const IfcPlateTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcPlateTypeEnum &in);
IfcPlateTypeEnum StrToIfcPlateTypeEnum(OdAnsiString val);
enum IfcProcedureTypeEnum_
{
  kIfcProcedureTypeEnum_ADVICE_CAUTION,
  kIfcProcedureTypeEnum_ADVICE_NOTE,
  kIfcProcedureTypeEnum_ADVICE_WARNING,
  kIfcProcedureTypeEnum_CALIBRATION,
  kIfcProcedureTypeEnum_DIAGNOSTIC,
  kIfcProcedureTypeEnum_SHUTDOWN,
  kIfcProcedureTypeEnum_STARTUP,
  kIfcProcedureTypeEnum_USERDEFINED,
  kIfcProcedureTypeEnum_NOTDEFINED,
  kIfcProcedureTypeEnum_unset
};
 
class IfcProcedureTypeEnum {
  IfcProcedureTypeEnum_ m_val;
public:
  IfcProcedureTypeEnum() : m_val(kIfcProcedureTypeEnum_unset) {};
  IfcProcedureTypeEnum(const IfcProcedureTypeEnum &other) : m_val(other.m_val) {};
  IfcProcedureTypeEnum(IfcProcedureTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcProcedureTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcProcedureTypeEnum_unset; };
  operator IfcProcedureTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcProcedureTypeEnum& operator = (const IfcProcedureTypeEnum_ val) { if (val < kIfcProcedureTypeEnum_unset) m_val = val; else m_val = kIfcProcedureTypeEnum_unset; return *this; };
  bool operator == (const IfcProcedureTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcProcedureTypeEnum &in);
IfcProcedureTypeEnum StrToIfcProcedureTypeEnum(OdAnsiString val);
enum IfcProfileTypeEnum_
{
  kIfcProfileTypeEnum_CURVE,
  kIfcProfileTypeEnum_AREA,
  kIfcProfileTypeEnum_unset
};
 
class IfcProfileTypeEnum {
  IfcProfileTypeEnum_ m_val;
public:
  IfcProfileTypeEnum() : m_val(kIfcProfileTypeEnum_unset) {};
  IfcProfileTypeEnum(const IfcProfileTypeEnum &other) : m_val(other.m_val) {};
  IfcProfileTypeEnum(IfcProfileTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcProfileTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcProfileTypeEnum_unset; };
  operator IfcProfileTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcProfileTypeEnum& operator = (const IfcProfileTypeEnum_ val) { if (val < kIfcProfileTypeEnum_unset) m_val = val; else m_val = kIfcProfileTypeEnum_unset; return *this; };
  bool operator == (const IfcProfileTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcProfileTypeEnum &in);
IfcProfileTypeEnum StrToIfcProfileTypeEnum(OdAnsiString val);
enum IfcProjectOrderRecordTypeEnum_
{
  kIfcProjectOrderRecordTypeEnum_CHANGE,
  kIfcProjectOrderRecordTypeEnum_MAINTENANCE,
  kIfcProjectOrderRecordTypeEnum_MOVE,
  kIfcProjectOrderRecordTypeEnum_PURCHASE,
  kIfcProjectOrderRecordTypeEnum_WORK,
  kIfcProjectOrderRecordTypeEnum_USERDEFINED,
  kIfcProjectOrderRecordTypeEnum_NOTDEFINED,
  kIfcProjectOrderRecordTypeEnum_unset
};
 
class IfcProjectOrderRecordTypeEnum {
  IfcProjectOrderRecordTypeEnum_ m_val;
public:
  IfcProjectOrderRecordTypeEnum() : m_val(kIfcProjectOrderRecordTypeEnum_unset) {};
  IfcProjectOrderRecordTypeEnum(const IfcProjectOrderRecordTypeEnum &other) : m_val(other.m_val) {};
  IfcProjectOrderRecordTypeEnum(IfcProjectOrderRecordTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcProjectOrderRecordTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcProjectOrderRecordTypeEnum_unset; };
  operator IfcProjectOrderRecordTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcProjectOrderRecordTypeEnum& operator = (const IfcProjectOrderRecordTypeEnum_ val) { if (val < kIfcProjectOrderRecordTypeEnum_unset) m_val = val; else m_val = kIfcProjectOrderRecordTypeEnum_unset; return *this; };
  bool operator == (const IfcProjectOrderRecordTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcProjectOrderRecordTypeEnum &in);
IfcProjectOrderRecordTypeEnum StrToIfcProjectOrderRecordTypeEnum(OdAnsiString val);
enum IfcProjectOrderTypeEnum_
{
  kIfcProjectOrderTypeEnum_CHANGEORDER,
  kIfcProjectOrderTypeEnum_MAINTENANCEWORKORDER,
  kIfcProjectOrderTypeEnum_MOVEORDER,
  kIfcProjectOrderTypeEnum_PURCHASEORDER,
  kIfcProjectOrderTypeEnum_WORKORDER,
  kIfcProjectOrderTypeEnum_USERDEFINED,
  kIfcProjectOrderTypeEnum_NOTDEFINED,
  kIfcProjectOrderTypeEnum_unset
};
 
class IfcProjectOrderTypeEnum {
  IfcProjectOrderTypeEnum_ m_val;
public:
  IfcProjectOrderTypeEnum() : m_val(kIfcProjectOrderTypeEnum_unset) {};
  IfcProjectOrderTypeEnum(const IfcProjectOrderTypeEnum &other) : m_val(other.m_val) {};
  IfcProjectOrderTypeEnum(IfcProjectOrderTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcProjectOrderTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcProjectOrderTypeEnum_unset; };
  operator IfcProjectOrderTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcProjectOrderTypeEnum& operator = (const IfcProjectOrderTypeEnum_ val) { if (val < kIfcProjectOrderTypeEnum_unset) m_val = val; else m_val = kIfcProjectOrderTypeEnum_unset; return *this; };
  bool operator == (const IfcProjectOrderTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcProjectOrderTypeEnum &in);
IfcProjectOrderTypeEnum StrToIfcProjectOrderTypeEnum(OdAnsiString val);
enum IfcProjectedOrTrueLengthEnum_
{
  kIfcProjectedOrTrueLengthEnum_PROJECTED_LENGTH,
  kIfcProjectedOrTrueLengthEnum_TRUE_LENGTH,
  kIfcProjectedOrTrueLengthEnum_unset
};
 
class IfcProjectedOrTrueLengthEnum {
  IfcProjectedOrTrueLengthEnum_ m_val;
public:
  IfcProjectedOrTrueLengthEnum() : m_val(kIfcProjectedOrTrueLengthEnum_unset) {};
  IfcProjectedOrTrueLengthEnum(const IfcProjectedOrTrueLengthEnum &other) : m_val(other.m_val) {};
  IfcProjectedOrTrueLengthEnum(IfcProjectedOrTrueLengthEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcProjectedOrTrueLengthEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcProjectedOrTrueLengthEnum_unset; };
  operator IfcProjectedOrTrueLengthEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcProjectedOrTrueLengthEnum& operator = (const IfcProjectedOrTrueLengthEnum_ val) { if (val < kIfcProjectedOrTrueLengthEnum_unset) m_val = val; else m_val = kIfcProjectedOrTrueLengthEnum_unset; return *this; };
  bool operator == (const IfcProjectedOrTrueLengthEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcProjectedOrTrueLengthEnum &in);
IfcProjectedOrTrueLengthEnum StrToIfcProjectedOrTrueLengthEnum(OdAnsiString val);
enum IfcPropertySourceEnum_
{
  kIfcPropertySourceEnum_DESIGN,
  kIfcPropertySourceEnum_DESIGNMAXIMUM,
  kIfcPropertySourceEnum_DESIGNMINIMUM,
  kIfcPropertySourceEnum_SIMULATED,
  kIfcPropertySourceEnum_ASBUILT,
  kIfcPropertySourceEnum_COMMISSIONING,
  kIfcPropertySourceEnum_MEASURED,
  kIfcPropertySourceEnum_USERDEFINED,
  kIfcPropertySourceEnum_NOTKNOWN,
  kIfcPropertySourceEnum_unset
};
 
class IfcPropertySourceEnum {
  IfcPropertySourceEnum_ m_val;
public:
  IfcPropertySourceEnum() : m_val(kIfcPropertySourceEnum_unset) {};
  IfcPropertySourceEnum(const IfcPropertySourceEnum &other) : m_val(other.m_val) {};
  IfcPropertySourceEnum(IfcPropertySourceEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcPropertySourceEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcPropertySourceEnum_unset; };
  operator IfcPropertySourceEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcPropertySourceEnum& operator = (const IfcPropertySourceEnum_ val) { if (val < kIfcPropertySourceEnum_unset) m_val = val; else m_val = kIfcPropertySourceEnum_unset; return *this; };
  bool operator == (const IfcPropertySourceEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcPropertySourceEnum &in);
IfcPropertySourceEnum StrToIfcPropertySourceEnum(OdAnsiString val);
enum IfcProtectiveDeviceTypeEnum_
{
  kIfcProtectiveDeviceTypeEnum_FUSEDISCONNECTOR,
  kIfcProtectiveDeviceTypeEnum_CIRCUITBREAKER,
  kIfcProtectiveDeviceTypeEnum_EARTHFAILUREDEVICE,
  kIfcProtectiveDeviceTypeEnum_RESIDUALCURRENTCIRCUITBREAKER,
  kIfcProtectiveDeviceTypeEnum_RESIDUALCURRENTSWITCH,
  kIfcProtectiveDeviceTypeEnum_VARISTOR,
  kIfcProtectiveDeviceTypeEnum_USERDEFINED,
  kIfcProtectiveDeviceTypeEnum_NOTDEFINED,
  kIfcProtectiveDeviceTypeEnum_unset
};
 
class IfcProtectiveDeviceTypeEnum {
  IfcProtectiveDeviceTypeEnum_ m_val;
public:
  IfcProtectiveDeviceTypeEnum() : m_val(kIfcProtectiveDeviceTypeEnum_unset) {};
  IfcProtectiveDeviceTypeEnum(const IfcProtectiveDeviceTypeEnum &other) : m_val(other.m_val) {};
  IfcProtectiveDeviceTypeEnum(IfcProtectiveDeviceTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcProtectiveDeviceTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcProtectiveDeviceTypeEnum_unset; };
  operator IfcProtectiveDeviceTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcProtectiveDeviceTypeEnum& operator = (const IfcProtectiveDeviceTypeEnum_ val) { if (val < kIfcProtectiveDeviceTypeEnum_unset) m_val = val; else m_val = kIfcProtectiveDeviceTypeEnum_unset; return *this; };
  bool operator == (const IfcProtectiveDeviceTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcProtectiveDeviceTypeEnum &in);
IfcProtectiveDeviceTypeEnum StrToIfcProtectiveDeviceTypeEnum(OdAnsiString val);
enum IfcPumpTypeEnum_
{
  kIfcPumpTypeEnum_CIRCULATOR,
  kIfcPumpTypeEnum_ENDSUCTION,
  kIfcPumpTypeEnum_SPLITCASE,
  kIfcPumpTypeEnum_VERTICALINLINE,
  kIfcPumpTypeEnum_VERTICALTURBINE,
  kIfcPumpTypeEnum_USERDEFINED,
  kIfcPumpTypeEnum_NOTDEFINED,
  kIfcPumpTypeEnum_unset
};
 
class IfcPumpTypeEnum {
  IfcPumpTypeEnum_ m_val;
public:
  IfcPumpTypeEnum() : m_val(kIfcPumpTypeEnum_unset) {};
  IfcPumpTypeEnum(const IfcPumpTypeEnum &other) : m_val(other.m_val) {};
  IfcPumpTypeEnum(IfcPumpTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcPumpTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcPumpTypeEnum_unset; };
  operator IfcPumpTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcPumpTypeEnum& operator = (const IfcPumpTypeEnum_ val) { if (val < kIfcPumpTypeEnum_unset) m_val = val; else m_val = kIfcPumpTypeEnum_unset; return *this; };
  bool operator == (const IfcPumpTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcPumpTypeEnum &in);
IfcPumpTypeEnum StrToIfcPumpTypeEnum(OdAnsiString val);
enum IfcRailingTypeEnum_
{
  kIfcRailingTypeEnum_HANDRAIL,
  kIfcRailingTypeEnum_GUARDRAIL,
  kIfcRailingTypeEnum_BALUSTRADE,
  kIfcRailingTypeEnum_USERDEFINED,
  kIfcRailingTypeEnum_NOTDEFINED,
  kIfcRailingTypeEnum_unset
};
 
class IfcRailingTypeEnum {
  IfcRailingTypeEnum_ m_val;
public:
  IfcRailingTypeEnum() : m_val(kIfcRailingTypeEnum_unset) {};
  IfcRailingTypeEnum(const IfcRailingTypeEnum &other) : m_val(other.m_val) {};
  IfcRailingTypeEnum(IfcRailingTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcRailingTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcRailingTypeEnum_unset; };
  operator IfcRailingTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcRailingTypeEnum& operator = (const IfcRailingTypeEnum_ val) { if (val < kIfcRailingTypeEnum_unset) m_val = val; else m_val = kIfcRailingTypeEnum_unset; return *this; };
  bool operator == (const IfcRailingTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcRailingTypeEnum &in);
IfcRailingTypeEnum StrToIfcRailingTypeEnum(OdAnsiString val);
enum IfcRampFlightTypeEnum_
{
  kIfcRampFlightTypeEnum_STRAIGHT,
  kIfcRampFlightTypeEnum_SPIRAL,
  kIfcRampFlightTypeEnum_USERDEFINED,
  kIfcRampFlightTypeEnum_NOTDEFINED,
  kIfcRampFlightTypeEnum_unset
};
 
class IfcRampFlightTypeEnum {
  IfcRampFlightTypeEnum_ m_val;
public:
  IfcRampFlightTypeEnum() : m_val(kIfcRampFlightTypeEnum_unset) {};
  IfcRampFlightTypeEnum(const IfcRampFlightTypeEnum &other) : m_val(other.m_val) {};
  IfcRampFlightTypeEnum(IfcRampFlightTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcRampFlightTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcRampFlightTypeEnum_unset; };
  operator IfcRampFlightTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcRampFlightTypeEnum& operator = (const IfcRampFlightTypeEnum_ val) { if (val < kIfcRampFlightTypeEnum_unset) m_val = val; else m_val = kIfcRampFlightTypeEnum_unset; return *this; };
  bool operator == (const IfcRampFlightTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcRampFlightTypeEnum &in);
IfcRampFlightTypeEnum StrToIfcRampFlightTypeEnum(OdAnsiString val);
enum IfcRampTypeEnum_
{
  kIfcRampTypeEnum_STRAIGHT_RUN_RAMP,
  kIfcRampTypeEnum_TWO_STRAIGHT_RUN_RAMP,
  kIfcRampTypeEnum_QUARTER_TURN_RAMP,
  kIfcRampTypeEnum_TWO_QUARTER_TURN_RAMP,
  kIfcRampTypeEnum_HALF_TURN_RAMP,
  kIfcRampTypeEnum_SPIRAL_RAMP,
  kIfcRampTypeEnum_USERDEFINED,
  kIfcRampTypeEnum_NOTDEFINED,
  kIfcRampTypeEnum_unset
};
 
class IfcRampTypeEnum {
  IfcRampTypeEnum_ m_val;
public:
  IfcRampTypeEnum() : m_val(kIfcRampTypeEnum_unset) {};
  IfcRampTypeEnum(const IfcRampTypeEnum &other) : m_val(other.m_val) {};
  IfcRampTypeEnum(IfcRampTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcRampTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcRampTypeEnum_unset; };
  operator IfcRampTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcRampTypeEnum& operator = (const IfcRampTypeEnum_ val) { if (val < kIfcRampTypeEnum_unset) m_val = val; else m_val = kIfcRampTypeEnum_unset; return *this; };
  bool operator == (const IfcRampTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcRampTypeEnum &in);
IfcRampTypeEnum StrToIfcRampTypeEnum(OdAnsiString val);
enum IfcReflectanceMethodEnum_
{
  kIfcReflectanceMethodEnum_BLINN,
  kIfcReflectanceMethodEnum_FLAT,
  kIfcReflectanceMethodEnum_GLASS,
  kIfcReflectanceMethodEnum_MATT,
  kIfcReflectanceMethodEnum_METAL,
  kIfcReflectanceMethodEnum_MIRROR,
  kIfcReflectanceMethodEnum_PHONG,
  kIfcReflectanceMethodEnum_PLASTIC,
  kIfcReflectanceMethodEnum_STRAUSS,
  kIfcReflectanceMethodEnum_NOTDEFINED,
  kIfcReflectanceMethodEnum_unset
};
 
class IfcReflectanceMethodEnum {
  IfcReflectanceMethodEnum_ m_val;
public:
  IfcReflectanceMethodEnum() : m_val(kIfcReflectanceMethodEnum_unset) {};
  IfcReflectanceMethodEnum(const IfcReflectanceMethodEnum &other) : m_val(other.m_val) {};
  IfcReflectanceMethodEnum(IfcReflectanceMethodEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcReflectanceMethodEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcReflectanceMethodEnum_unset; };
  operator IfcReflectanceMethodEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcReflectanceMethodEnum& operator = (const IfcReflectanceMethodEnum_ val) { if (val < kIfcReflectanceMethodEnum_unset) m_val = val; else m_val = kIfcReflectanceMethodEnum_unset; return *this; };
  bool operator == (const IfcReflectanceMethodEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcReflectanceMethodEnum &in);
IfcReflectanceMethodEnum StrToIfcReflectanceMethodEnum(OdAnsiString val);
enum IfcReinforcingBarRoleEnum_
{
  kIfcReinforcingBarRoleEnum_MAIN,
  kIfcReinforcingBarRoleEnum_SHEAR,
  kIfcReinforcingBarRoleEnum_LIGATURE,
  kIfcReinforcingBarRoleEnum_STUD,
  kIfcReinforcingBarRoleEnum_PUNCHING,
  kIfcReinforcingBarRoleEnum_EDGE,
  kIfcReinforcingBarRoleEnum_RING,
  kIfcReinforcingBarRoleEnum_USERDEFINED,
  kIfcReinforcingBarRoleEnum_NOTDEFINED,
  kIfcReinforcingBarRoleEnum_unset
};
 
class IfcReinforcingBarRoleEnum {
  IfcReinforcingBarRoleEnum_ m_val;
public:
  IfcReinforcingBarRoleEnum() : m_val(kIfcReinforcingBarRoleEnum_unset) {};
  IfcReinforcingBarRoleEnum(const IfcReinforcingBarRoleEnum &other) : m_val(other.m_val) {};
  IfcReinforcingBarRoleEnum(IfcReinforcingBarRoleEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcReinforcingBarRoleEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcReinforcingBarRoleEnum_unset; };
  operator IfcReinforcingBarRoleEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcReinforcingBarRoleEnum& operator = (const IfcReinforcingBarRoleEnum_ val) { if (val < kIfcReinforcingBarRoleEnum_unset) m_val = val; else m_val = kIfcReinforcingBarRoleEnum_unset; return *this; };
  bool operator == (const IfcReinforcingBarRoleEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcReinforcingBarRoleEnum &in);
IfcReinforcingBarRoleEnum StrToIfcReinforcingBarRoleEnum(OdAnsiString val);
enum IfcReinforcingBarSurfaceEnum_
{
  kIfcReinforcingBarSurfaceEnum_PLAIN,
  kIfcReinforcingBarSurfaceEnum_TEXTURED,
  kIfcReinforcingBarSurfaceEnum_unset
};
 
class IfcReinforcingBarSurfaceEnum {
  IfcReinforcingBarSurfaceEnum_ m_val;
public:
  IfcReinforcingBarSurfaceEnum() : m_val(kIfcReinforcingBarSurfaceEnum_unset) {};
  IfcReinforcingBarSurfaceEnum(const IfcReinforcingBarSurfaceEnum &other) : m_val(other.m_val) {};
  IfcReinforcingBarSurfaceEnum(IfcReinforcingBarSurfaceEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcReinforcingBarSurfaceEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcReinforcingBarSurfaceEnum_unset; };
  operator IfcReinforcingBarSurfaceEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcReinforcingBarSurfaceEnum& operator = (const IfcReinforcingBarSurfaceEnum_ val) { if (val < kIfcReinforcingBarSurfaceEnum_unset) m_val = val; else m_val = kIfcReinforcingBarSurfaceEnum_unset; return *this; };
  bool operator == (const IfcReinforcingBarSurfaceEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcReinforcingBarSurfaceEnum &in);
IfcReinforcingBarSurfaceEnum StrToIfcReinforcingBarSurfaceEnum(OdAnsiString val);
enum IfcResourceConsumptionEnum_
{
  kIfcResourceConsumptionEnum_CONSUMED,
  kIfcResourceConsumptionEnum_PARTIALLYCONSUMED,
  kIfcResourceConsumptionEnum_NOTCONSUMED,
  kIfcResourceConsumptionEnum_OCCUPIED,
  kIfcResourceConsumptionEnum_PARTIALLYOCCUPIED,
  kIfcResourceConsumptionEnum_NOTOCCUPIED,
  kIfcResourceConsumptionEnum_USERDEFINED,
  kIfcResourceConsumptionEnum_NOTDEFINED,
  kIfcResourceConsumptionEnum_unset
};
 
class IfcResourceConsumptionEnum {
  IfcResourceConsumptionEnum_ m_val;
public:
  IfcResourceConsumptionEnum() : m_val(kIfcResourceConsumptionEnum_unset) {};
  IfcResourceConsumptionEnum(const IfcResourceConsumptionEnum &other) : m_val(other.m_val) {};
  IfcResourceConsumptionEnum(IfcResourceConsumptionEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcResourceConsumptionEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcResourceConsumptionEnum_unset; };
  operator IfcResourceConsumptionEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcResourceConsumptionEnum& operator = (const IfcResourceConsumptionEnum_ val) { if (val < kIfcResourceConsumptionEnum_unset) m_val = val; else m_val = kIfcResourceConsumptionEnum_unset; return *this; };
  bool operator == (const IfcResourceConsumptionEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcResourceConsumptionEnum &in);
IfcResourceConsumptionEnum StrToIfcResourceConsumptionEnum(OdAnsiString val);
enum IfcRibPlateDirectionEnum_
{
  kIfcRibPlateDirectionEnum_DIRECTION_X,
  kIfcRibPlateDirectionEnum_DIRECTION_Y,
  kIfcRibPlateDirectionEnum_unset
};
 
class IfcRibPlateDirectionEnum {
  IfcRibPlateDirectionEnum_ m_val;
public:
  IfcRibPlateDirectionEnum() : m_val(kIfcRibPlateDirectionEnum_unset) {};
  IfcRibPlateDirectionEnum(const IfcRibPlateDirectionEnum &other) : m_val(other.m_val) {};
  IfcRibPlateDirectionEnum(IfcRibPlateDirectionEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcRibPlateDirectionEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcRibPlateDirectionEnum_unset; };
  operator IfcRibPlateDirectionEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcRibPlateDirectionEnum& operator = (const IfcRibPlateDirectionEnum_ val) { if (val < kIfcRibPlateDirectionEnum_unset) m_val = val; else m_val = kIfcRibPlateDirectionEnum_unset; return *this; };
  bool operator == (const IfcRibPlateDirectionEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcRibPlateDirectionEnum &in);
IfcRibPlateDirectionEnum StrToIfcRibPlateDirectionEnum(OdAnsiString val);
enum IfcRoleEnum_
{
  kIfcRoleEnum_SUPPLIER,
  kIfcRoleEnum_MANUFACTURER,
  kIfcRoleEnum_CONTRACTOR,
  kIfcRoleEnum_SUBCONTRACTOR,
  kIfcRoleEnum_ARCHITECT,
  kIfcRoleEnum_STRUCTURALENGINEER,
  kIfcRoleEnum_COSTENGINEER,
  kIfcRoleEnum_CLIENT,
  kIfcRoleEnum_BUILDINGOWNER,
  kIfcRoleEnum_BUILDINGOPERATOR,
  kIfcRoleEnum_MECHANICALENGINEER,
  kIfcRoleEnum_ELECTRICALENGINEER,
  kIfcRoleEnum_PROJECTMANAGER,
  kIfcRoleEnum_FACILITIESMANAGER,
  kIfcRoleEnum_CIVILENGINEER,
  kIfcRoleEnum_COMISSIONINGENGINEER,
  kIfcRoleEnum_ENGINEER,
  kIfcRoleEnum_OWNER,
  kIfcRoleEnum_CONSULTANT,
  kIfcRoleEnum_CONSTRUCTIONMANAGER,
  kIfcRoleEnum_FIELDCONSTRUCTIONMANAGER,
  kIfcRoleEnum_RESELLER,
  kIfcRoleEnum_USERDEFINED,
  kIfcRoleEnum_unset
};
 
class IfcRoleEnum {
  IfcRoleEnum_ m_val;
public:
  IfcRoleEnum() : m_val(kIfcRoleEnum_unset) {};
  IfcRoleEnum(const IfcRoleEnum &other) : m_val(other.m_val) {};
  IfcRoleEnum(IfcRoleEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcRoleEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcRoleEnum_unset; };
  operator IfcRoleEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcRoleEnum& operator = (const IfcRoleEnum_ val) { if (val < kIfcRoleEnum_unset) m_val = val; else m_val = kIfcRoleEnum_unset; return *this; };
  bool operator == (const IfcRoleEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcRoleEnum &in);
IfcRoleEnum StrToIfcRoleEnum(OdAnsiString val);
enum IfcRoofTypeEnum_
{
  kIfcRoofTypeEnum_FLAT_ROOF,
  kIfcRoofTypeEnum_SHED_ROOF,
  kIfcRoofTypeEnum_GABLE_ROOF,
  kIfcRoofTypeEnum_HIP_ROOF,
  kIfcRoofTypeEnum_HIPPED_GABLE_ROOF,
  kIfcRoofTypeEnum_GAMBREL_ROOF,
  kIfcRoofTypeEnum_MANSARD_ROOF,
  kIfcRoofTypeEnum_BARREL_ROOF,
  kIfcRoofTypeEnum_RAINBOW_ROOF,
  kIfcRoofTypeEnum_BUTTERFLY_ROOF,
  kIfcRoofTypeEnum_PAVILION_ROOF,
  kIfcRoofTypeEnum_DOME_ROOF,
  kIfcRoofTypeEnum_FREEFORM,
  kIfcRoofTypeEnum_NOTDEFINED,
  kIfcRoofTypeEnum_unset
};
 
class IfcRoofTypeEnum {
  IfcRoofTypeEnum_ m_val;
public:
  IfcRoofTypeEnum() : m_val(kIfcRoofTypeEnum_unset) {};
  IfcRoofTypeEnum(const IfcRoofTypeEnum &other) : m_val(other.m_val) {};
  IfcRoofTypeEnum(IfcRoofTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcRoofTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcRoofTypeEnum_unset; };
  operator IfcRoofTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcRoofTypeEnum& operator = (const IfcRoofTypeEnum_ val) { if (val < kIfcRoofTypeEnum_unset) m_val = val; else m_val = kIfcRoofTypeEnum_unset; return *this; };
  bool operator == (const IfcRoofTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcRoofTypeEnum &in);
IfcRoofTypeEnum StrToIfcRoofTypeEnum(OdAnsiString val);
enum IfcSIPrefix_
{
  kIfcSIPrefix_EXA,
  kIfcSIPrefix_PETA,
  kIfcSIPrefix_TERA,
  kIfcSIPrefix_GIGA,
  kIfcSIPrefix_MEGA,
  kIfcSIPrefix_KILO,
  kIfcSIPrefix_HECTO,
  kIfcSIPrefix_DECA,
  kIfcSIPrefix_DECI,
  kIfcSIPrefix_CENTI,
  kIfcSIPrefix_MILLI,
  kIfcSIPrefix_MICRO,
  kIfcSIPrefix_NANO,
  kIfcSIPrefix_PICO,
  kIfcSIPrefix_FEMTO,
  kIfcSIPrefix_ATTO,
  kIfcSIPrefix_unset
};
 
class IfcSIPrefix {
  IfcSIPrefix_ m_val;
public:
  IfcSIPrefix() : m_val(kIfcSIPrefix_unset) {};
  IfcSIPrefix(const IfcSIPrefix &other) : m_val(other.m_val) {};
  IfcSIPrefix(IfcSIPrefix_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcSIPrefix_unset ? 1 : 0; };
  void nullify() { m_val = kIfcSIPrefix_unset; };
  operator IfcSIPrefix_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcSIPrefix& operator = (const IfcSIPrefix_ val) { if (val < kIfcSIPrefix_unset) m_val = val; else m_val = kIfcSIPrefix_unset; return *this; };
  bool operator == (const IfcSIPrefix &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcSIPrefix &in);
IfcSIPrefix StrToIfcSIPrefix(OdAnsiString val);
enum IfcSIUnitName_
{
  kIfcSIUnitName_AMPERE,
  kIfcSIUnitName_BECQUEREL,
  kIfcSIUnitName_CANDELA,
  kIfcSIUnitName_COULOMB,
  kIfcSIUnitName_CUBIC_METRE,
  kIfcSIUnitName_DEGREE_CELSIUS,
  kIfcSIUnitName_FARAD,
  kIfcSIUnitName_GRAM,
  kIfcSIUnitName_GRAY,
  kIfcSIUnitName_HENRY,
  kIfcSIUnitName_HERTZ,
  kIfcSIUnitName_JOULE,
  kIfcSIUnitName_KELVIN,
  kIfcSIUnitName_LUMEN,
  kIfcSIUnitName_LUX,
  kIfcSIUnitName_METRE,
  kIfcSIUnitName_MOLE,
  kIfcSIUnitName_NEWTON,
  kIfcSIUnitName_OHM,
  kIfcSIUnitName_PASCAL,
  kIfcSIUnitName_RADIAN,
  kIfcSIUnitName_SECOND,
  kIfcSIUnitName_SIEMENS,
  kIfcSIUnitName_SIEVERT,
  kIfcSIUnitName_SQUARE_METRE,
  kIfcSIUnitName_STERADIAN,
  kIfcSIUnitName_TESLA,
  kIfcSIUnitName_VOLT,
  kIfcSIUnitName_WATT,
  kIfcSIUnitName_WEBER,
  kIfcSIUnitName_unset
};
 
class IfcSIUnitName {
  IfcSIUnitName_ m_val;
public:
  IfcSIUnitName() : m_val(kIfcSIUnitName_unset) {};
  IfcSIUnitName(const IfcSIUnitName &other) : m_val(other.m_val) {};
  IfcSIUnitName(IfcSIUnitName_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcSIUnitName_unset ? 1 : 0; };
  void nullify() { m_val = kIfcSIUnitName_unset; };
  operator IfcSIUnitName_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcSIUnitName& operator = (const IfcSIUnitName_ val) { if (val < kIfcSIUnitName_unset) m_val = val; else m_val = kIfcSIUnitName_unset; return *this; };
  bool operator == (const IfcSIUnitName &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcSIUnitName &in);
IfcSIUnitName StrToIfcSIUnitName(OdAnsiString val);
enum IfcSanitaryTerminalTypeEnum_
{
  kIfcSanitaryTerminalTypeEnum_BATH,
  kIfcSanitaryTerminalTypeEnum_BIDET,
  kIfcSanitaryTerminalTypeEnum_CISTERN,
  kIfcSanitaryTerminalTypeEnum_SHOWER,
  kIfcSanitaryTerminalTypeEnum_SINK,
  kIfcSanitaryTerminalTypeEnum_SANITARYFOUNTAIN,
  kIfcSanitaryTerminalTypeEnum_TOILETPAN,
  kIfcSanitaryTerminalTypeEnum_URINAL,
  kIfcSanitaryTerminalTypeEnum_WASHHANDBASIN,
  kIfcSanitaryTerminalTypeEnum_WCSEAT,
  kIfcSanitaryTerminalTypeEnum_USERDEFINED,
  kIfcSanitaryTerminalTypeEnum_NOTDEFINED,
  kIfcSanitaryTerminalTypeEnum_unset
};
 
class IfcSanitaryTerminalTypeEnum {
  IfcSanitaryTerminalTypeEnum_ m_val;
public:
  IfcSanitaryTerminalTypeEnum() : m_val(kIfcSanitaryTerminalTypeEnum_unset) {};
  IfcSanitaryTerminalTypeEnum(const IfcSanitaryTerminalTypeEnum &other) : m_val(other.m_val) {};
  IfcSanitaryTerminalTypeEnum(IfcSanitaryTerminalTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcSanitaryTerminalTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcSanitaryTerminalTypeEnum_unset; };
  operator IfcSanitaryTerminalTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcSanitaryTerminalTypeEnum& operator = (const IfcSanitaryTerminalTypeEnum_ val) { if (val < kIfcSanitaryTerminalTypeEnum_unset) m_val = val; else m_val = kIfcSanitaryTerminalTypeEnum_unset; return *this; };
  bool operator == (const IfcSanitaryTerminalTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcSanitaryTerminalTypeEnum &in);
IfcSanitaryTerminalTypeEnum StrToIfcSanitaryTerminalTypeEnum(OdAnsiString val);
enum IfcSectionTypeEnum_
{
  kIfcSectionTypeEnum_UNIFORM,
  kIfcSectionTypeEnum_TAPERED,
  kIfcSectionTypeEnum_unset
};
 
class IfcSectionTypeEnum {
  IfcSectionTypeEnum_ m_val;
public:
  IfcSectionTypeEnum() : m_val(kIfcSectionTypeEnum_unset) {};
  IfcSectionTypeEnum(const IfcSectionTypeEnum &other) : m_val(other.m_val) {};
  IfcSectionTypeEnum(IfcSectionTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcSectionTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcSectionTypeEnum_unset; };
  operator IfcSectionTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcSectionTypeEnum& operator = (const IfcSectionTypeEnum_ val) { if (val < kIfcSectionTypeEnum_unset) m_val = val; else m_val = kIfcSectionTypeEnum_unset; return *this; };
  bool operator == (const IfcSectionTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcSectionTypeEnum &in);
IfcSectionTypeEnum StrToIfcSectionTypeEnum(OdAnsiString val);
enum IfcSensorTypeEnum_
{
  kIfcSensorTypeEnum_CO2SENSOR,
  kIfcSensorTypeEnum_FIRESENSOR,
  kIfcSensorTypeEnum_FLOWSENSOR,
  kIfcSensorTypeEnum_GASSENSOR,
  kIfcSensorTypeEnum_HEATSENSOR,
  kIfcSensorTypeEnum_HUMIDITYSENSOR,
  kIfcSensorTypeEnum_LIGHTSENSOR,
  kIfcSensorTypeEnum_MOISTURESENSOR,
  kIfcSensorTypeEnum_MOVEMENTSENSOR,
  kIfcSensorTypeEnum_PRESSURESENSOR,
  kIfcSensorTypeEnum_SMOKESENSOR,
  kIfcSensorTypeEnum_SOUNDSENSOR,
  kIfcSensorTypeEnum_TEMPERATURESENSOR,
  kIfcSensorTypeEnum_USERDEFINED,
  kIfcSensorTypeEnum_NOTDEFINED,
  kIfcSensorTypeEnum_unset
};
 
class IfcSensorTypeEnum {
  IfcSensorTypeEnum_ m_val;
public:
  IfcSensorTypeEnum() : m_val(kIfcSensorTypeEnum_unset) {};
  IfcSensorTypeEnum(const IfcSensorTypeEnum &other) : m_val(other.m_val) {};
  IfcSensorTypeEnum(IfcSensorTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcSensorTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcSensorTypeEnum_unset; };
  operator IfcSensorTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcSensorTypeEnum& operator = (const IfcSensorTypeEnum_ val) { if (val < kIfcSensorTypeEnum_unset) m_val = val; else m_val = kIfcSensorTypeEnum_unset; return *this; };
  bool operator == (const IfcSensorTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcSensorTypeEnum &in);
IfcSensorTypeEnum StrToIfcSensorTypeEnum(OdAnsiString val);
enum IfcSequenceEnum_
{
  kIfcSequenceEnum_START_START,
  kIfcSequenceEnum_START_FINISH,
  kIfcSequenceEnum_FINISH_START,
  kIfcSequenceEnum_FINISH_FINISH,
  kIfcSequenceEnum_NOTDEFINED,
  kIfcSequenceEnum_unset
};
 
class IfcSequenceEnum {
  IfcSequenceEnum_ m_val;
public:
  IfcSequenceEnum() : m_val(kIfcSequenceEnum_unset) {};
  IfcSequenceEnum(const IfcSequenceEnum &other) : m_val(other.m_val) {};
  IfcSequenceEnum(IfcSequenceEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcSequenceEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcSequenceEnum_unset; };
  operator IfcSequenceEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcSequenceEnum& operator = (const IfcSequenceEnum_ val) { if (val < kIfcSequenceEnum_unset) m_val = val; else m_val = kIfcSequenceEnum_unset; return *this; };
  bool operator == (const IfcSequenceEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcSequenceEnum &in);
IfcSequenceEnum StrToIfcSequenceEnum(OdAnsiString val);
enum IfcServiceLifeFactorTypeEnum_
{
  kIfcServiceLifeFactorTypeEnum_A_QUALITYOFCOMPONENTS,
  kIfcServiceLifeFactorTypeEnum_B_DESIGNLEVEL,
  kIfcServiceLifeFactorTypeEnum_C_WORKEXECUTIONLEVEL,
  kIfcServiceLifeFactorTypeEnum_D_INDOORENVIRONMENT,
  kIfcServiceLifeFactorTypeEnum_E_OUTDOORENVIRONMENT,
  kIfcServiceLifeFactorTypeEnum_F_INUSECONDITIONS,
  kIfcServiceLifeFactorTypeEnum_G_MAINTENANCELEVEL,
  kIfcServiceLifeFactorTypeEnum_USERDEFINED,
  kIfcServiceLifeFactorTypeEnum_NOTDEFINED,
  kIfcServiceLifeFactorTypeEnum_unset
};
 
class IfcServiceLifeFactorTypeEnum {
  IfcServiceLifeFactorTypeEnum_ m_val;
public:
  IfcServiceLifeFactorTypeEnum() : m_val(kIfcServiceLifeFactorTypeEnum_unset) {};
  IfcServiceLifeFactorTypeEnum(const IfcServiceLifeFactorTypeEnum &other) : m_val(other.m_val) {};
  IfcServiceLifeFactorTypeEnum(IfcServiceLifeFactorTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcServiceLifeFactorTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcServiceLifeFactorTypeEnum_unset; };
  operator IfcServiceLifeFactorTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcServiceLifeFactorTypeEnum& operator = (const IfcServiceLifeFactorTypeEnum_ val) { if (val < kIfcServiceLifeFactorTypeEnum_unset) m_val = val; else m_val = kIfcServiceLifeFactorTypeEnum_unset; return *this; };
  bool operator == (const IfcServiceLifeFactorTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcServiceLifeFactorTypeEnum &in);
IfcServiceLifeFactorTypeEnum StrToIfcServiceLifeFactorTypeEnum(OdAnsiString val);
enum IfcServiceLifeTypeEnum_
{
  kIfcServiceLifeTypeEnum_ACTUALSERVICELIFE,
  kIfcServiceLifeTypeEnum_EXPECTEDSERVICELIFE,
  kIfcServiceLifeTypeEnum_OPTIMISTICREFERENCESERVICELIFE,
  kIfcServiceLifeTypeEnum_PESSIMISTICREFERENCESERVICELIFE,
  kIfcServiceLifeTypeEnum_REFERENCESERVICELIFE,
  kIfcServiceLifeTypeEnum_unset
};
 
class IfcServiceLifeTypeEnum {
  IfcServiceLifeTypeEnum_ m_val;
public:
  IfcServiceLifeTypeEnum() : m_val(kIfcServiceLifeTypeEnum_unset) {};
  IfcServiceLifeTypeEnum(const IfcServiceLifeTypeEnum &other) : m_val(other.m_val) {};
  IfcServiceLifeTypeEnum(IfcServiceLifeTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcServiceLifeTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcServiceLifeTypeEnum_unset; };
  operator IfcServiceLifeTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcServiceLifeTypeEnum& operator = (const IfcServiceLifeTypeEnum_ val) { if (val < kIfcServiceLifeTypeEnum_unset) m_val = val; else m_val = kIfcServiceLifeTypeEnum_unset; return *this; };
  bool operator == (const IfcServiceLifeTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcServiceLifeTypeEnum &in);
IfcServiceLifeTypeEnum StrToIfcServiceLifeTypeEnum(OdAnsiString val);
enum IfcSlabTypeEnum_
{
  kIfcSlabTypeEnum_FLOOR,
  kIfcSlabTypeEnum_ROOF,
  kIfcSlabTypeEnum_LANDING,
  kIfcSlabTypeEnum_BASESLAB,
  kIfcSlabTypeEnum_USERDEFINED,
  kIfcSlabTypeEnum_NOTDEFINED,
  kIfcSlabTypeEnum_unset
};
 
class IfcSlabTypeEnum {
  IfcSlabTypeEnum_ m_val;
public:
  IfcSlabTypeEnum() : m_val(kIfcSlabTypeEnum_unset) {};
  IfcSlabTypeEnum(const IfcSlabTypeEnum &other) : m_val(other.m_val) {};
  IfcSlabTypeEnum(IfcSlabTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcSlabTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcSlabTypeEnum_unset; };
  operator IfcSlabTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcSlabTypeEnum& operator = (const IfcSlabTypeEnum_ val) { if (val < kIfcSlabTypeEnum_unset) m_val = val; else m_val = kIfcSlabTypeEnum_unset; return *this; };
  bool operator == (const IfcSlabTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcSlabTypeEnum &in);
IfcSlabTypeEnum StrToIfcSlabTypeEnum(OdAnsiString val);
enum IfcSoundScaleEnum_
{
  kIfcSoundScaleEnum_DBA,
  kIfcSoundScaleEnum_DBB,
  kIfcSoundScaleEnum_DBC,
  kIfcSoundScaleEnum_NC,
  kIfcSoundScaleEnum_NR,
  kIfcSoundScaleEnum_USERDEFINED,
  kIfcSoundScaleEnum_NOTDEFINED,
  kIfcSoundScaleEnum_unset
};
 
class IfcSoundScaleEnum {
  IfcSoundScaleEnum_ m_val;
public:
  IfcSoundScaleEnum() : m_val(kIfcSoundScaleEnum_unset) {};
  IfcSoundScaleEnum(const IfcSoundScaleEnum &other) : m_val(other.m_val) {};
  IfcSoundScaleEnum(IfcSoundScaleEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcSoundScaleEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcSoundScaleEnum_unset; };
  operator IfcSoundScaleEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcSoundScaleEnum& operator = (const IfcSoundScaleEnum_ val) { if (val < kIfcSoundScaleEnum_unset) m_val = val; else m_val = kIfcSoundScaleEnum_unset; return *this; };
  bool operator == (const IfcSoundScaleEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcSoundScaleEnum &in);
IfcSoundScaleEnum StrToIfcSoundScaleEnum(OdAnsiString val);
enum IfcSpaceHeaterTypeEnum_
{
  kIfcSpaceHeaterTypeEnum_SECTIONALRADIATOR,
  kIfcSpaceHeaterTypeEnum_PANELRADIATOR,
  kIfcSpaceHeaterTypeEnum_TUBULARRADIATOR,
  kIfcSpaceHeaterTypeEnum_CONVECTOR,
  kIfcSpaceHeaterTypeEnum_BASEBOARDHEATER,
  kIfcSpaceHeaterTypeEnum_FINNEDTUBEUNIT,
  kIfcSpaceHeaterTypeEnum_UNITHEATER,
  kIfcSpaceHeaterTypeEnum_USERDEFINED,
  kIfcSpaceHeaterTypeEnum_NOTDEFINED,
  kIfcSpaceHeaterTypeEnum_unset
};
 
class IfcSpaceHeaterTypeEnum {
  IfcSpaceHeaterTypeEnum_ m_val;
public:
  IfcSpaceHeaterTypeEnum() : m_val(kIfcSpaceHeaterTypeEnum_unset) {};
  IfcSpaceHeaterTypeEnum(const IfcSpaceHeaterTypeEnum &other) : m_val(other.m_val) {};
  IfcSpaceHeaterTypeEnum(IfcSpaceHeaterTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcSpaceHeaterTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcSpaceHeaterTypeEnum_unset; };
  operator IfcSpaceHeaterTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcSpaceHeaterTypeEnum& operator = (const IfcSpaceHeaterTypeEnum_ val) { if (val < kIfcSpaceHeaterTypeEnum_unset) m_val = val; else m_val = kIfcSpaceHeaterTypeEnum_unset; return *this; };
  bool operator == (const IfcSpaceHeaterTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcSpaceHeaterTypeEnum &in);
IfcSpaceHeaterTypeEnum StrToIfcSpaceHeaterTypeEnum(OdAnsiString val);
enum IfcSpaceTypeEnum_
{
  kIfcSpaceTypeEnum_USERDEFINED,
  kIfcSpaceTypeEnum_NOTDEFINED,
  kIfcSpaceTypeEnum_unset
};
 
class IfcSpaceTypeEnum {
  IfcSpaceTypeEnum_ m_val;
public:
  IfcSpaceTypeEnum() : m_val(kIfcSpaceTypeEnum_unset) {};
  IfcSpaceTypeEnum(const IfcSpaceTypeEnum &other) : m_val(other.m_val) {};
  IfcSpaceTypeEnum(IfcSpaceTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcSpaceTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcSpaceTypeEnum_unset; };
  operator IfcSpaceTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcSpaceTypeEnum& operator = (const IfcSpaceTypeEnum_ val) { if (val < kIfcSpaceTypeEnum_unset) m_val = val; else m_val = kIfcSpaceTypeEnum_unset; return *this; };
  bool operator == (const IfcSpaceTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcSpaceTypeEnum &in);
IfcSpaceTypeEnum StrToIfcSpaceTypeEnum(OdAnsiString val);
enum IfcStackTerminalTypeEnum_
{
  kIfcStackTerminalTypeEnum_BIRDCAGE,
  kIfcStackTerminalTypeEnum_COWL,
  kIfcStackTerminalTypeEnum_RAINWATERHOPPER,
  kIfcStackTerminalTypeEnum_USERDEFINED,
  kIfcStackTerminalTypeEnum_NOTDEFINED,
  kIfcStackTerminalTypeEnum_unset
};
 
class IfcStackTerminalTypeEnum {
  IfcStackTerminalTypeEnum_ m_val;
public:
  IfcStackTerminalTypeEnum() : m_val(kIfcStackTerminalTypeEnum_unset) {};
  IfcStackTerminalTypeEnum(const IfcStackTerminalTypeEnum &other) : m_val(other.m_val) {};
  IfcStackTerminalTypeEnum(IfcStackTerminalTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcStackTerminalTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcStackTerminalTypeEnum_unset; };
  operator IfcStackTerminalTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcStackTerminalTypeEnum& operator = (const IfcStackTerminalTypeEnum_ val) { if (val < kIfcStackTerminalTypeEnum_unset) m_val = val; else m_val = kIfcStackTerminalTypeEnum_unset; return *this; };
  bool operator == (const IfcStackTerminalTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcStackTerminalTypeEnum &in);
IfcStackTerminalTypeEnum StrToIfcStackTerminalTypeEnum(OdAnsiString val);
enum IfcStairFlightTypeEnum_
{
  kIfcStairFlightTypeEnum_STRAIGHT,
  kIfcStairFlightTypeEnum_WINDER,
  kIfcStairFlightTypeEnum_SPIRAL,
  kIfcStairFlightTypeEnum_CURVED,
  kIfcStairFlightTypeEnum_FREEFORM,
  kIfcStairFlightTypeEnum_USERDEFINED,
  kIfcStairFlightTypeEnum_NOTDEFINED,
  kIfcStairFlightTypeEnum_unset
};
 
class IfcStairFlightTypeEnum {
  IfcStairFlightTypeEnum_ m_val;
public:
  IfcStairFlightTypeEnum() : m_val(kIfcStairFlightTypeEnum_unset) {};
  IfcStairFlightTypeEnum(const IfcStairFlightTypeEnum &other) : m_val(other.m_val) {};
  IfcStairFlightTypeEnum(IfcStairFlightTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcStairFlightTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcStairFlightTypeEnum_unset; };
  operator IfcStairFlightTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcStairFlightTypeEnum& operator = (const IfcStairFlightTypeEnum_ val) { if (val < kIfcStairFlightTypeEnum_unset) m_val = val; else m_val = kIfcStairFlightTypeEnum_unset; return *this; };
  bool operator == (const IfcStairFlightTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcStairFlightTypeEnum &in);
IfcStairFlightTypeEnum StrToIfcStairFlightTypeEnum(OdAnsiString val);
enum IfcStairTypeEnum_
{
  kIfcStairTypeEnum_STRAIGHT_RUN_STAIR,
  kIfcStairTypeEnum_TWO_STRAIGHT_RUN_STAIR,
  kIfcStairTypeEnum_QUARTER_WINDING_STAIR,
  kIfcStairTypeEnum_QUARTER_TURN_STAIR,
  kIfcStairTypeEnum_HALF_WINDING_STAIR,
  kIfcStairTypeEnum_HALF_TURN_STAIR,
  kIfcStairTypeEnum_TWO_QUARTER_WINDING_STAIR,
  kIfcStairTypeEnum_TWO_QUARTER_TURN_STAIR,
  kIfcStairTypeEnum_THREE_QUARTER_WINDING_STAIR,
  kIfcStairTypeEnum_THREE_QUARTER_TURN_STAIR,
  kIfcStairTypeEnum_SPIRAL_STAIR,
  kIfcStairTypeEnum_DOUBLE_RETURN_STAIR,
  kIfcStairTypeEnum_CURVED_RUN_STAIR,
  kIfcStairTypeEnum_TWO_CURVED_RUN_STAIR,
  kIfcStairTypeEnum_USERDEFINED,
  kIfcStairTypeEnum_NOTDEFINED,
  kIfcStairTypeEnum_unset
};
 
class IfcStairTypeEnum {
  IfcStairTypeEnum_ m_val;
public:
  IfcStairTypeEnum() : m_val(kIfcStairTypeEnum_unset) {};
  IfcStairTypeEnum(const IfcStairTypeEnum &other) : m_val(other.m_val) {};
  IfcStairTypeEnum(IfcStairTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcStairTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcStairTypeEnum_unset; };
  operator IfcStairTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcStairTypeEnum& operator = (const IfcStairTypeEnum_ val) { if (val < kIfcStairTypeEnum_unset) m_val = val; else m_val = kIfcStairTypeEnum_unset; return *this; };
  bool operator == (const IfcStairTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcStairTypeEnum &in);
IfcStairTypeEnum StrToIfcStairTypeEnum(OdAnsiString val);
enum IfcStateEnum_
{
  kIfcStateEnum_READWRITE,
  kIfcStateEnum_READONLY,
  kIfcStateEnum_LOCKED,
  kIfcStateEnum_READWRITELOCKED,
  kIfcStateEnum_READONLYLOCKED,
  kIfcStateEnum_unset
};
 
class IfcStateEnum {
  IfcStateEnum_ m_val;
public:
  IfcStateEnum() : m_val(kIfcStateEnum_unset) {};
  IfcStateEnum(const IfcStateEnum &other) : m_val(other.m_val) {};
  IfcStateEnum(IfcStateEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcStateEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcStateEnum_unset; };
  operator IfcStateEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcStateEnum& operator = (const IfcStateEnum_ val) { if (val < kIfcStateEnum_unset) m_val = val; else m_val = kIfcStateEnum_unset; return *this; };
  bool operator == (const IfcStateEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcStateEnum &in);
IfcStateEnum StrToIfcStateEnum(OdAnsiString val);
enum IfcStructuralCurveTypeEnum_
{
  kIfcStructuralCurveTypeEnum_RIGID_JOINED_MEMBER,
  kIfcStructuralCurveTypeEnum_PIN_JOINED_MEMBER,
  kIfcStructuralCurveTypeEnum_CABLE,
  kIfcStructuralCurveTypeEnum_TENSION_MEMBER,
  kIfcStructuralCurveTypeEnum_COMPRESSION_MEMBER,
  kIfcStructuralCurveTypeEnum_USERDEFINED,
  kIfcStructuralCurveTypeEnum_NOTDEFINED,
  kIfcStructuralCurveTypeEnum_unset
};
 
class IfcStructuralCurveTypeEnum {
  IfcStructuralCurveTypeEnum_ m_val;
public:
  IfcStructuralCurveTypeEnum() : m_val(kIfcStructuralCurveTypeEnum_unset) {};
  IfcStructuralCurveTypeEnum(const IfcStructuralCurveTypeEnum &other) : m_val(other.m_val) {};
  IfcStructuralCurveTypeEnum(IfcStructuralCurveTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcStructuralCurveTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcStructuralCurveTypeEnum_unset; };
  operator IfcStructuralCurveTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcStructuralCurveTypeEnum& operator = (const IfcStructuralCurveTypeEnum_ val) { if (val < kIfcStructuralCurveTypeEnum_unset) m_val = val; else m_val = kIfcStructuralCurveTypeEnum_unset; return *this; };
  bool operator == (const IfcStructuralCurveTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcStructuralCurveTypeEnum &in);
IfcStructuralCurveTypeEnum StrToIfcStructuralCurveTypeEnum(OdAnsiString val);
enum IfcStructuralSurfaceTypeEnum_
{
  kIfcStructuralSurfaceTypeEnum_BENDING_ELEMENT,
  kIfcStructuralSurfaceTypeEnum_MEMBRANE_ELEMENT,
  kIfcStructuralSurfaceTypeEnum_SHELL,
  kIfcStructuralSurfaceTypeEnum_USERDEFINED,
  kIfcStructuralSurfaceTypeEnum_NOTDEFINED,
  kIfcStructuralSurfaceTypeEnum_unset
};
 
class IfcStructuralSurfaceTypeEnum {
  IfcStructuralSurfaceTypeEnum_ m_val;
public:
  IfcStructuralSurfaceTypeEnum() : m_val(kIfcStructuralSurfaceTypeEnum_unset) {};
  IfcStructuralSurfaceTypeEnum(const IfcStructuralSurfaceTypeEnum &other) : m_val(other.m_val) {};
  IfcStructuralSurfaceTypeEnum(IfcStructuralSurfaceTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcStructuralSurfaceTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcStructuralSurfaceTypeEnum_unset; };
  operator IfcStructuralSurfaceTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcStructuralSurfaceTypeEnum& operator = (const IfcStructuralSurfaceTypeEnum_ val) { if (val < kIfcStructuralSurfaceTypeEnum_unset) m_val = val; else m_val = kIfcStructuralSurfaceTypeEnum_unset; return *this; };
  bool operator == (const IfcStructuralSurfaceTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcStructuralSurfaceTypeEnum &in);
IfcStructuralSurfaceTypeEnum StrToIfcStructuralSurfaceTypeEnum(OdAnsiString val);
enum IfcSurfaceSide_
{
  kIfcSurfaceSide_POSITIVE,
  kIfcSurfaceSide_NEGATIVE,
  kIfcSurfaceSide_BOTH,
  kIfcSurfaceSide_unset
};
 
class IfcSurfaceSide {
  IfcSurfaceSide_ m_val;
public:
  IfcSurfaceSide() : m_val(kIfcSurfaceSide_unset) {};
  IfcSurfaceSide(const IfcSurfaceSide &other) : m_val(other.m_val) {};
  IfcSurfaceSide(IfcSurfaceSide_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcSurfaceSide_unset ? 1 : 0; };
  void nullify() { m_val = kIfcSurfaceSide_unset; };
  operator IfcSurfaceSide_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcSurfaceSide& operator = (const IfcSurfaceSide_ val) { if (val < kIfcSurfaceSide_unset) m_val = val; else m_val = kIfcSurfaceSide_unset; return *this; };
  bool operator == (const IfcSurfaceSide &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcSurfaceSide &in);
IfcSurfaceSide StrToIfcSurfaceSide(OdAnsiString val);
enum IfcSurfaceTextureEnum_
{
  kIfcSurfaceTextureEnum_BUMP,
  kIfcSurfaceTextureEnum_OPACITY,
  kIfcSurfaceTextureEnum_REFLECTION,
  kIfcSurfaceTextureEnum_SELFILLUMINATION,
  kIfcSurfaceTextureEnum_SHININESS,
  kIfcSurfaceTextureEnum_SPECULAR,
  kIfcSurfaceTextureEnum_TEXTURE,
  kIfcSurfaceTextureEnum_TRANSPARENCYMAP,
  kIfcSurfaceTextureEnum_NOTDEFINED,
  kIfcSurfaceTextureEnum_unset
};
 
class IfcSurfaceTextureEnum {
  IfcSurfaceTextureEnum_ m_val;
public:
  IfcSurfaceTextureEnum() : m_val(kIfcSurfaceTextureEnum_unset) {};
  IfcSurfaceTextureEnum(const IfcSurfaceTextureEnum &other) : m_val(other.m_val) {};
  IfcSurfaceTextureEnum(IfcSurfaceTextureEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcSurfaceTextureEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcSurfaceTextureEnum_unset; };
  operator IfcSurfaceTextureEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcSurfaceTextureEnum& operator = (const IfcSurfaceTextureEnum_ val) { if (val < kIfcSurfaceTextureEnum_unset) m_val = val; else m_val = kIfcSurfaceTextureEnum_unset; return *this; };
  bool operator == (const IfcSurfaceTextureEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcSurfaceTextureEnum &in);
IfcSurfaceTextureEnum StrToIfcSurfaceTextureEnum(OdAnsiString val);
enum IfcSwitchingDeviceTypeEnum_
{
  kIfcSwitchingDeviceTypeEnum_CONTACTOR,
  kIfcSwitchingDeviceTypeEnum_EMERGENCYSTOP,
  kIfcSwitchingDeviceTypeEnum_STARTER,
  kIfcSwitchingDeviceTypeEnum_SWITCHDISCONNECTOR,
  kIfcSwitchingDeviceTypeEnum_TOGGLESWITCH,
  kIfcSwitchingDeviceTypeEnum_USERDEFINED,
  kIfcSwitchingDeviceTypeEnum_NOTDEFINED,
  kIfcSwitchingDeviceTypeEnum_unset
};
 
class IfcSwitchingDeviceTypeEnum {
  IfcSwitchingDeviceTypeEnum_ m_val;
public:
  IfcSwitchingDeviceTypeEnum() : m_val(kIfcSwitchingDeviceTypeEnum_unset) {};
  IfcSwitchingDeviceTypeEnum(const IfcSwitchingDeviceTypeEnum &other) : m_val(other.m_val) {};
  IfcSwitchingDeviceTypeEnum(IfcSwitchingDeviceTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcSwitchingDeviceTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcSwitchingDeviceTypeEnum_unset; };
  operator IfcSwitchingDeviceTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcSwitchingDeviceTypeEnum& operator = (const IfcSwitchingDeviceTypeEnum_ val) { if (val < kIfcSwitchingDeviceTypeEnum_unset) m_val = val; else m_val = kIfcSwitchingDeviceTypeEnum_unset; return *this; };
  bool operator == (const IfcSwitchingDeviceTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcSwitchingDeviceTypeEnum &in);
IfcSwitchingDeviceTypeEnum StrToIfcSwitchingDeviceTypeEnum(OdAnsiString val);
enum IfcTankTypeEnum_
{
  kIfcTankTypeEnum_PREFORMED,
  kIfcTankTypeEnum_SECTIONAL,
  kIfcTankTypeEnum_EXPANSION,
  kIfcTankTypeEnum_PRESSUREVESSEL,
  kIfcTankTypeEnum_USERDEFINED,
  kIfcTankTypeEnum_NOTDEFINED,
  kIfcTankTypeEnum_unset
};
 
class IfcTankTypeEnum {
  IfcTankTypeEnum_ m_val;
public:
  IfcTankTypeEnum() : m_val(kIfcTankTypeEnum_unset) {};
  IfcTankTypeEnum(const IfcTankTypeEnum &other) : m_val(other.m_val) {};
  IfcTankTypeEnum(IfcTankTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcTankTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcTankTypeEnum_unset; };
  operator IfcTankTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcTankTypeEnum& operator = (const IfcTankTypeEnum_ val) { if (val < kIfcTankTypeEnum_unset) m_val = val; else m_val = kIfcTankTypeEnum_unset; return *this; };
  bool operator == (const IfcTankTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcTankTypeEnum &in);
IfcTankTypeEnum StrToIfcTankTypeEnum(OdAnsiString val);
enum IfcTendonTypeEnum_
{
  kIfcTendonTypeEnum_STRAND,
  kIfcTendonTypeEnum_WIRE,
  kIfcTendonTypeEnum_BAR,
  kIfcTendonTypeEnum_COATED,
  kIfcTendonTypeEnum_USERDEFINED,
  kIfcTendonTypeEnum_NOTDEFINED,
  kIfcTendonTypeEnum_unset
};
 
class IfcTendonTypeEnum {
  IfcTendonTypeEnum_ m_val;
public:
  IfcTendonTypeEnum() : m_val(kIfcTendonTypeEnum_unset) {};
  IfcTendonTypeEnum(const IfcTendonTypeEnum &other) : m_val(other.m_val) {};
  IfcTendonTypeEnum(IfcTendonTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcTendonTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcTendonTypeEnum_unset; };
  operator IfcTendonTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcTendonTypeEnum& operator = (const IfcTendonTypeEnum_ val) { if (val < kIfcTendonTypeEnum_unset) m_val = val; else m_val = kIfcTendonTypeEnum_unset; return *this; };
  bool operator == (const IfcTendonTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcTendonTypeEnum &in);
IfcTendonTypeEnum StrToIfcTendonTypeEnum(OdAnsiString val);
enum IfcTextPath_
{
  kIfcTextPath_LEFT,
  kIfcTextPath_RIGHT,
  kIfcTextPath_UP,
  kIfcTextPath_DOWN,
  kIfcTextPath_unset
};
 
class IfcTextPath {
  IfcTextPath_ m_val;
public:
  IfcTextPath() : m_val(kIfcTextPath_unset) {};
  IfcTextPath(const IfcTextPath &other) : m_val(other.m_val) {};
  IfcTextPath(IfcTextPath_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcTextPath_unset ? 1 : 0; };
  void nullify() { m_val = kIfcTextPath_unset; };
  operator IfcTextPath_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcTextPath& operator = (const IfcTextPath_ val) { if (val < kIfcTextPath_unset) m_val = val; else m_val = kIfcTextPath_unset; return *this; };
  bool operator == (const IfcTextPath &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcTextPath &in);
IfcTextPath StrToIfcTextPath(OdAnsiString val);
enum IfcThermalLoadSourceEnum_
{
  kIfcThermalLoadSourceEnum_PEOPLE,
  kIfcThermalLoadSourceEnum_LIGHTING,
  kIfcThermalLoadSourceEnum_EQUIPMENT,
  kIfcThermalLoadSourceEnum_VENTILATIONINDOORAIR,
  kIfcThermalLoadSourceEnum_VENTILATIONOUTSIDEAIR,
  kIfcThermalLoadSourceEnum_RECIRCULATEDAIR,
  kIfcThermalLoadSourceEnum_EXHAUSTAIR,
  kIfcThermalLoadSourceEnum_AIREXCHANGERATE,
  kIfcThermalLoadSourceEnum_DRYBULBTEMPERATURE,
  kIfcThermalLoadSourceEnum_RELATIVEHUMIDITY,
  kIfcThermalLoadSourceEnum_INFILTRATION,
  kIfcThermalLoadSourceEnum_USERDEFINED,
  kIfcThermalLoadSourceEnum_NOTDEFINED,
  kIfcThermalLoadSourceEnum_unset
};
 
class IfcThermalLoadSourceEnum {
  IfcThermalLoadSourceEnum_ m_val;
public:
  IfcThermalLoadSourceEnum() : m_val(kIfcThermalLoadSourceEnum_unset) {};
  IfcThermalLoadSourceEnum(const IfcThermalLoadSourceEnum &other) : m_val(other.m_val) {};
  IfcThermalLoadSourceEnum(IfcThermalLoadSourceEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcThermalLoadSourceEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcThermalLoadSourceEnum_unset; };
  operator IfcThermalLoadSourceEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcThermalLoadSourceEnum& operator = (const IfcThermalLoadSourceEnum_ val) { if (val < kIfcThermalLoadSourceEnum_unset) m_val = val; else m_val = kIfcThermalLoadSourceEnum_unset; return *this; };
  bool operator == (const IfcThermalLoadSourceEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcThermalLoadSourceEnum &in);
IfcThermalLoadSourceEnum StrToIfcThermalLoadSourceEnum(OdAnsiString val);
enum IfcThermalLoadTypeEnum_
{
  kIfcThermalLoadTypeEnum_SENSIBLE,
  kIfcThermalLoadTypeEnum_LATENT,
  kIfcThermalLoadTypeEnum_RADIANT,
  kIfcThermalLoadTypeEnum_NOTDEFINED,
  kIfcThermalLoadTypeEnum_unset
};
 
class IfcThermalLoadTypeEnum {
  IfcThermalLoadTypeEnum_ m_val;
public:
  IfcThermalLoadTypeEnum() : m_val(kIfcThermalLoadTypeEnum_unset) {};
  IfcThermalLoadTypeEnum(const IfcThermalLoadTypeEnum &other) : m_val(other.m_val) {};
  IfcThermalLoadTypeEnum(IfcThermalLoadTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcThermalLoadTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcThermalLoadTypeEnum_unset; };
  operator IfcThermalLoadTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcThermalLoadTypeEnum& operator = (const IfcThermalLoadTypeEnum_ val) { if (val < kIfcThermalLoadTypeEnum_unset) m_val = val; else m_val = kIfcThermalLoadTypeEnum_unset; return *this; };
  bool operator == (const IfcThermalLoadTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcThermalLoadTypeEnum &in);
IfcThermalLoadTypeEnum StrToIfcThermalLoadTypeEnum(OdAnsiString val);
enum IfcTimeSeriesDataTypeEnum_
{
  kIfcTimeSeriesDataTypeEnum_CONTINUOUS,
  kIfcTimeSeriesDataTypeEnum_DISCRETE,
  kIfcTimeSeriesDataTypeEnum_DISCRETEBINARY,
  kIfcTimeSeriesDataTypeEnum_PIECEWISEBINARY,
  kIfcTimeSeriesDataTypeEnum_PIECEWISECONSTANT,
  kIfcTimeSeriesDataTypeEnum_PIECEWISECONTINUOUS,
  kIfcTimeSeriesDataTypeEnum_NOTDEFINED,
  kIfcTimeSeriesDataTypeEnum_unset
};
 
class IfcTimeSeriesDataTypeEnum {
  IfcTimeSeriesDataTypeEnum_ m_val;
public:
  IfcTimeSeriesDataTypeEnum() : m_val(kIfcTimeSeriesDataTypeEnum_unset) {};
  IfcTimeSeriesDataTypeEnum(const IfcTimeSeriesDataTypeEnum &other) : m_val(other.m_val) {};
  IfcTimeSeriesDataTypeEnum(IfcTimeSeriesDataTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcTimeSeriesDataTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcTimeSeriesDataTypeEnum_unset; };
  operator IfcTimeSeriesDataTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcTimeSeriesDataTypeEnum& operator = (const IfcTimeSeriesDataTypeEnum_ val) { if (val < kIfcTimeSeriesDataTypeEnum_unset) m_val = val; else m_val = kIfcTimeSeriesDataTypeEnum_unset; return *this; };
  bool operator == (const IfcTimeSeriesDataTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcTimeSeriesDataTypeEnum &in);
IfcTimeSeriesDataTypeEnum StrToIfcTimeSeriesDataTypeEnum(OdAnsiString val);
enum IfcTimeSeriesScheduleTypeEnum_
{
  kIfcTimeSeriesScheduleTypeEnum_ANNUAL,
  kIfcTimeSeriesScheduleTypeEnum_MONTHLY,
  kIfcTimeSeriesScheduleTypeEnum_WEEKLY,
  kIfcTimeSeriesScheduleTypeEnum_DAILY,
  kIfcTimeSeriesScheduleTypeEnum_USERDEFINED,
  kIfcTimeSeriesScheduleTypeEnum_NOTDEFINED,
  kIfcTimeSeriesScheduleTypeEnum_unset
};
 
class IfcTimeSeriesScheduleTypeEnum {
  IfcTimeSeriesScheduleTypeEnum_ m_val;
public:
  IfcTimeSeriesScheduleTypeEnum() : m_val(kIfcTimeSeriesScheduleTypeEnum_unset) {};
  IfcTimeSeriesScheduleTypeEnum(const IfcTimeSeriesScheduleTypeEnum &other) : m_val(other.m_val) {};
  IfcTimeSeriesScheduleTypeEnum(IfcTimeSeriesScheduleTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcTimeSeriesScheduleTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcTimeSeriesScheduleTypeEnum_unset; };
  operator IfcTimeSeriesScheduleTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcTimeSeriesScheduleTypeEnum& operator = (const IfcTimeSeriesScheduleTypeEnum_ val) { if (val < kIfcTimeSeriesScheduleTypeEnum_unset) m_val = val; else m_val = kIfcTimeSeriesScheduleTypeEnum_unset; return *this; };
  bool operator == (const IfcTimeSeriesScheduleTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcTimeSeriesScheduleTypeEnum &in);
IfcTimeSeriesScheduleTypeEnum StrToIfcTimeSeriesScheduleTypeEnum(OdAnsiString val);
enum IfcTransformerTypeEnum_
{
  kIfcTransformerTypeEnum_CURRENT,
  kIfcTransformerTypeEnum_FREQUENCY,
  kIfcTransformerTypeEnum_VOLTAGE,
  kIfcTransformerTypeEnum_USERDEFINED,
  kIfcTransformerTypeEnum_NOTDEFINED,
  kIfcTransformerTypeEnum_unset
};
 
class IfcTransformerTypeEnum {
  IfcTransformerTypeEnum_ m_val;
public:
  IfcTransformerTypeEnum() : m_val(kIfcTransformerTypeEnum_unset) {};
  IfcTransformerTypeEnum(const IfcTransformerTypeEnum &other) : m_val(other.m_val) {};
  IfcTransformerTypeEnum(IfcTransformerTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcTransformerTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcTransformerTypeEnum_unset; };
  operator IfcTransformerTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcTransformerTypeEnum& operator = (const IfcTransformerTypeEnum_ val) { if (val < kIfcTransformerTypeEnum_unset) m_val = val; else m_val = kIfcTransformerTypeEnum_unset; return *this; };
  bool operator == (const IfcTransformerTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcTransformerTypeEnum &in);
IfcTransformerTypeEnum StrToIfcTransformerTypeEnum(OdAnsiString val);
enum IfcTransitionCode_
{
  kIfcTransitionCode_DISCONTINUOUS,
  kIfcTransitionCode_CONTINUOUS,
  kIfcTransitionCode_CONTSAMEGRADIENT,
  kIfcTransitionCode_CONTSAMEGRADIENTSAMECURVATURE,
  kIfcTransitionCode_unset
};
 
class IfcTransitionCode {
  IfcTransitionCode_ m_val;
public:
  IfcTransitionCode() : m_val(kIfcTransitionCode_unset) {};
  IfcTransitionCode(const IfcTransitionCode &other) : m_val(other.m_val) {};
  IfcTransitionCode(IfcTransitionCode_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcTransitionCode_unset ? 1 : 0; };
  void nullify() { m_val = kIfcTransitionCode_unset; };
  operator IfcTransitionCode_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcTransitionCode& operator = (const IfcTransitionCode_ val) { if (val < kIfcTransitionCode_unset) m_val = val; else m_val = kIfcTransitionCode_unset; return *this; };
  bool operator == (const IfcTransitionCode &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcTransitionCode &in);
IfcTransitionCode StrToIfcTransitionCode(OdAnsiString val);
enum IfcTransportElementTypeEnum_
{
  kIfcTransportElementTypeEnum_ELEVATOR,
  kIfcTransportElementTypeEnum_ESCALATOR,
  kIfcTransportElementTypeEnum_MOVINGWALKWAY,
  kIfcTransportElementTypeEnum_USERDEFINED,
  kIfcTransportElementTypeEnum_NOTDEFINED,
  kIfcTransportElementTypeEnum_unset
};
 
class IfcTransportElementTypeEnum {
  IfcTransportElementTypeEnum_ m_val;
public:
  IfcTransportElementTypeEnum() : m_val(kIfcTransportElementTypeEnum_unset) {};
  IfcTransportElementTypeEnum(const IfcTransportElementTypeEnum &other) : m_val(other.m_val) {};
  IfcTransportElementTypeEnum(IfcTransportElementTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcTransportElementTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcTransportElementTypeEnum_unset; };
  operator IfcTransportElementTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcTransportElementTypeEnum& operator = (const IfcTransportElementTypeEnum_ val) { if (val < kIfcTransportElementTypeEnum_unset) m_val = val; else m_val = kIfcTransportElementTypeEnum_unset; return *this; };
  bool operator == (const IfcTransportElementTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcTransportElementTypeEnum &in);
IfcTransportElementTypeEnum StrToIfcTransportElementTypeEnum(OdAnsiString val);
enum IfcTrimmingPreference_
{
  kIfcTrimmingPreference_CARTESIAN,
  kIfcTrimmingPreference_PARAMETER,
  kIfcTrimmingPreference_UNSPECIFIED,
  kIfcTrimmingPreference_unset
};
 
class IfcTrimmingPreference {
  IfcTrimmingPreference_ m_val;
public:
  IfcTrimmingPreference() : m_val(kIfcTrimmingPreference_unset) {};
  IfcTrimmingPreference(const IfcTrimmingPreference &other) : m_val(other.m_val) {};
  IfcTrimmingPreference(IfcTrimmingPreference_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcTrimmingPreference_unset ? 1 : 0; };
  void nullify() { m_val = kIfcTrimmingPreference_unset; };
  operator IfcTrimmingPreference_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcTrimmingPreference& operator = (const IfcTrimmingPreference_ val) { if (val < kIfcTrimmingPreference_unset) m_val = val; else m_val = kIfcTrimmingPreference_unset; return *this; };
  bool operator == (const IfcTrimmingPreference &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcTrimmingPreference &in);
IfcTrimmingPreference StrToIfcTrimmingPreference(OdAnsiString val);
enum IfcTubeBundleTypeEnum_
{
  kIfcTubeBundleTypeEnum_FINNED,
  kIfcTubeBundleTypeEnum_USERDEFINED,
  kIfcTubeBundleTypeEnum_NOTDEFINED,
  kIfcTubeBundleTypeEnum_unset
};
 
class IfcTubeBundleTypeEnum {
  IfcTubeBundleTypeEnum_ m_val;
public:
  IfcTubeBundleTypeEnum() : m_val(kIfcTubeBundleTypeEnum_unset) {};
  IfcTubeBundleTypeEnum(const IfcTubeBundleTypeEnum &other) : m_val(other.m_val) {};
  IfcTubeBundleTypeEnum(IfcTubeBundleTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcTubeBundleTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcTubeBundleTypeEnum_unset; };
  operator IfcTubeBundleTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcTubeBundleTypeEnum& operator = (const IfcTubeBundleTypeEnum_ val) { if (val < kIfcTubeBundleTypeEnum_unset) m_val = val; else m_val = kIfcTubeBundleTypeEnum_unset; return *this; };
  bool operator == (const IfcTubeBundleTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcTubeBundleTypeEnum &in);
IfcTubeBundleTypeEnum StrToIfcTubeBundleTypeEnum(OdAnsiString val);
enum IfcUnitEnum_
{
  kIfcUnitEnum_ABSORBEDDOSEUNIT,
  kIfcUnitEnum_AMOUNTOFSUBSTANCEUNIT,
  kIfcUnitEnum_AREAUNIT,
  kIfcUnitEnum_DOSEEQUIVALENTUNIT,
  kIfcUnitEnum_ELECTRICCAPACITANCEUNIT,
  kIfcUnitEnum_ELECTRICCHARGEUNIT,
  kIfcUnitEnum_ELECTRICCONDUCTANCEUNIT,
  kIfcUnitEnum_ELECTRICCURRENTUNIT,
  kIfcUnitEnum_ELECTRICRESISTANCEUNIT,
  kIfcUnitEnum_ELECTRICVOLTAGEUNIT,
  kIfcUnitEnum_ENERGYUNIT,
  kIfcUnitEnum_FORCEUNIT,
  kIfcUnitEnum_FREQUENCYUNIT,
  kIfcUnitEnum_ILLUMINANCEUNIT,
  kIfcUnitEnum_INDUCTANCEUNIT,
  kIfcUnitEnum_LENGTHUNIT,
  kIfcUnitEnum_LUMINOUSFLUXUNIT,
  kIfcUnitEnum_LUMINOUSINTENSITYUNIT,
  kIfcUnitEnum_MAGNETICFLUXDENSITYUNIT,
  kIfcUnitEnum_MAGNETICFLUXUNIT,
  kIfcUnitEnum_MASSUNIT,
  kIfcUnitEnum_PLANEANGLEUNIT,
  kIfcUnitEnum_POWERUNIT,
  kIfcUnitEnum_PRESSUREUNIT,
  kIfcUnitEnum_RADIOACTIVITYUNIT,
  kIfcUnitEnum_SOLIDANGLEUNIT,
  kIfcUnitEnum_THERMODYNAMICTEMPERATUREUNIT,
  kIfcUnitEnum_TIMEUNIT,
  kIfcUnitEnum_VOLUMEUNIT,
  kIfcUnitEnum_USERDEFINED,
  kIfcUnitEnum_unset
};
 
class IfcUnitEnum {
  IfcUnitEnum_ m_val;
public:
  IfcUnitEnum() : m_val(kIfcUnitEnum_unset) {};
  IfcUnitEnum(const IfcUnitEnum &other) : m_val(other.m_val) {};
  IfcUnitEnum(IfcUnitEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcUnitEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcUnitEnum_unset; };
  operator IfcUnitEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcUnitEnum& operator = (const IfcUnitEnum_ val) { if (val < kIfcUnitEnum_unset) m_val = val; else m_val = kIfcUnitEnum_unset; return *this; };
  bool operator == (const IfcUnitEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcUnitEnum &in);
IfcUnitEnum StrToIfcUnitEnum(OdAnsiString val);
enum IfcUnitaryEquipmentTypeEnum_
{
  kIfcUnitaryEquipmentTypeEnum_AIRHANDLER,
  kIfcUnitaryEquipmentTypeEnum_AIRCONDITIONINGUNIT,
  kIfcUnitaryEquipmentTypeEnum_SPLITSYSTEM,
  kIfcUnitaryEquipmentTypeEnum_ROOFTOPUNIT,
  kIfcUnitaryEquipmentTypeEnum_USERDEFINED,
  kIfcUnitaryEquipmentTypeEnum_NOTDEFINED,
  kIfcUnitaryEquipmentTypeEnum_unset
};
 
class IfcUnitaryEquipmentTypeEnum {
  IfcUnitaryEquipmentTypeEnum_ m_val;
public:
  IfcUnitaryEquipmentTypeEnum() : m_val(kIfcUnitaryEquipmentTypeEnum_unset) {};
  IfcUnitaryEquipmentTypeEnum(const IfcUnitaryEquipmentTypeEnum &other) : m_val(other.m_val) {};
  IfcUnitaryEquipmentTypeEnum(IfcUnitaryEquipmentTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcUnitaryEquipmentTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcUnitaryEquipmentTypeEnum_unset; };
  operator IfcUnitaryEquipmentTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcUnitaryEquipmentTypeEnum& operator = (const IfcUnitaryEquipmentTypeEnum_ val) { if (val < kIfcUnitaryEquipmentTypeEnum_unset) m_val = val; else m_val = kIfcUnitaryEquipmentTypeEnum_unset; return *this; };
  bool operator == (const IfcUnitaryEquipmentTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcUnitaryEquipmentTypeEnum &in);
IfcUnitaryEquipmentTypeEnum StrToIfcUnitaryEquipmentTypeEnum(OdAnsiString val);
enum IfcValveTypeEnum_
{
  kIfcValveTypeEnum_AIRRELEASE,
  kIfcValveTypeEnum_ANTIVACUUM,
  kIfcValveTypeEnum_CHANGEOVER,
  kIfcValveTypeEnum_CHECK,
  kIfcValveTypeEnum_COMMISSIONING,
  kIfcValveTypeEnum_DIVERTING,
  kIfcValveTypeEnum_DRAWOFFCOCK,
  kIfcValveTypeEnum_DOUBLECHECK,
  kIfcValveTypeEnum_DOUBLEREGULATING,
  kIfcValveTypeEnum_FAUCET,
  kIfcValveTypeEnum_FLUSHING,
  kIfcValveTypeEnum_GASCOCK,
  kIfcValveTypeEnum_GASTAP,
  kIfcValveTypeEnum_ISOLATING,
  kIfcValveTypeEnum_MIXING,
  kIfcValveTypeEnum_PRESSUREREDUCING,
  kIfcValveTypeEnum_PRESSURERELIEF,
  kIfcValveTypeEnum_REGULATING,
  kIfcValveTypeEnum_SAFETYCUTOFF,
  kIfcValveTypeEnum_STEAMTRAP,
  kIfcValveTypeEnum_STOPCOCK,
  kIfcValveTypeEnum_USERDEFINED,
  kIfcValveTypeEnum_NOTDEFINED,
  kIfcValveTypeEnum_unset
};
 
class IfcValveTypeEnum {
  IfcValveTypeEnum_ m_val;
public:
  IfcValveTypeEnum() : m_val(kIfcValveTypeEnum_unset) {};
  IfcValveTypeEnum(const IfcValveTypeEnum &other) : m_val(other.m_val) {};
  IfcValveTypeEnum(IfcValveTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcValveTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcValveTypeEnum_unset; };
  operator IfcValveTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcValveTypeEnum& operator = (const IfcValveTypeEnum_ val) { if (val < kIfcValveTypeEnum_unset) m_val = val; else m_val = kIfcValveTypeEnum_unset; return *this; };
  bool operator == (const IfcValveTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcValveTypeEnum &in);
IfcValveTypeEnum StrToIfcValveTypeEnum(OdAnsiString val);
enum IfcVibrationIsolatorTypeEnum_
{
  kIfcVibrationIsolatorTypeEnum_COMPRESSION,
  kIfcVibrationIsolatorTypeEnum_SPRING,
  kIfcVibrationIsolatorTypeEnum_USERDEFINED,
  kIfcVibrationIsolatorTypeEnum_NOTDEFINED,
  kIfcVibrationIsolatorTypeEnum_unset
};
 
class IfcVibrationIsolatorTypeEnum {
  IfcVibrationIsolatorTypeEnum_ m_val;
public:
  IfcVibrationIsolatorTypeEnum() : m_val(kIfcVibrationIsolatorTypeEnum_unset) {};
  IfcVibrationIsolatorTypeEnum(const IfcVibrationIsolatorTypeEnum &other) : m_val(other.m_val) {};
  IfcVibrationIsolatorTypeEnum(IfcVibrationIsolatorTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcVibrationIsolatorTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcVibrationIsolatorTypeEnum_unset; };
  operator IfcVibrationIsolatorTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcVibrationIsolatorTypeEnum& operator = (const IfcVibrationIsolatorTypeEnum_ val) { if (val < kIfcVibrationIsolatorTypeEnum_unset) m_val = val; else m_val = kIfcVibrationIsolatorTypeEnum_unset; return *this; };
  bool operator == (const IfcVibrationIsolatorTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcVibrationIsolatorTypeEnum &in);
IfcVibrationIsolatorTypeEnum StrToIfcVibrationIsolatorTypeEnum(OdAnsiString val);
enum IfcWallTypeEnum_
{
  kIfcWallTypeEnum_STANDARD,
  kIfcWallTypeEnum_POLYGONAL,
  kIfcWallTypeEnum_SHEAR,
  kIfcWallTypeEnum_ELEMENTEDWALL,
  kIfcWallTypeEnum_PLUMBINGWALL,
  kIfcWallTypeEnum_USERDEFINED,
  kIfcWallTypeEnum_NOTDEFINED,
  kIfcWallTypeEnum_unset
};
 
class IfcWallTypeEnum {
  IfcWallTypeEnum_ m_val;
public:
  IfcWallTypeEnum() : m_val(kIfcWallTypeEnum_unset) {};
  IfcWallTypeEnum(const IfcWallTypeEnum &other) : m_val(other.m_val) {};
  IfcWallTypeEnum(IfcWallTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcWallTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcWallTypeEnum_unset; };
  operator IfcWallTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcWallTypeEnum& operator = (const IfcWallTypeEnum_ val) { if (val < kIfcWallTypeEnum_unset) m_val = val; else m_val = kIfcWallTypeEnum_unset; return *this; };
  bool operator == (const IfcWallTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcWallTypeEnum &in);
IfcWallTypeEnum StrToIfcWallTypeEnum(OdAnsiString val);
enum IfcWasteTerminalTypeEnum_
{
  kIfcWasteTerminalTypeEnum_FLOORTRAP,
  kIfcWasteTerminalTypeEnum_FLOORWASTE,
  kIfcWasteTerminalTypeEnum_GULLYSUMP,
  kIfcWasteTerminalTypeEnum_GULLYTRAP,
  kIfcWasteTerminalTypeEnum_GREASEINTERCEPTOR,
  kIfcWasteTerminalTypeEnum_OILINTERCEPTOR,
  kIfcWasteTerminalTypeEnum_PETROLINTERCEPTOR,
  kIfcWasteTerminalTypeEnum_ROOFDRAIN,
  kIfcWasteTerminalTypeEnum_WASTEDISPOSALUNIT,
  kIfcWasteTerminalTypeEnum_WASTETRAP,
  kIfcWasteTerminalTypeEnum_USERDEFINED,
  kIfcWasteTerminalTypeEnum_NOTDEFINED,
  kIfcWasteTerminalTypeEnum_unset
};
 
class IfcWasteTerminalTypeEnum {
  IfcWasteTerminalTypeEnum_ m_val;
public:
  IfcWasteTerminalTypeEnum() : m_val(kIfcWasteTerminalTypeEnum_unset) {};
  IfcWasteTerminalTypeEnum(const IfcWasteTerminalTypeEnum &other) : m_val(other.m_val) {};
  IfcWasteTerminalTypeEnum(IfcWasteTerminalTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcWasteTerminalTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcWasteTerminalTypeEnum_unset; };
  operator IfcWasteTerminalTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcWasteTerminalTypeEnum& operator = (const IfcWasteTerminalTypeEnum_ val) { if (val < kIfcWasteTerminalTypeEnum_unset) m_val = val; else m_val = kIfcWasteTerminalTypeEnum_unset; return *this; };
  bool operator == (const IfcWasteTerminalTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcWasteTerminalTypeEnum &in);
IfcWasteTerminalTypeEnum StrToIfcWasteTerminalTypeEnum(OdAnsiString val);
enum IfcWindowPanelOperationEnum_
{
  kIfcWindowPanelOperationEnum_SIDEHUNGRIGHTHAND,
  kIfcWindowPanelOperationEnum_SIDEHUNGLEFTHAND,
  kIfcWindowPanelOperationEnum_TILTANDTURNRIGHTHAND,
  kIfcWindowPanelOperationEnum_TILTANDTURNLEFTHAND,
  kIfcWindowPanelOperationEnum_TOPHUNG,
  kIfcWindowPanelOperationEnum_BOTTOMHUNG,
  kIfcWindowPanelOperationEnum_PIVOTHORIZONTAL,
  kIfcWindowPanelOperationEnum_PIVOTVERTICAL,
  kIfcWindowPanelOperationEnum_SLIDINGHORIZONTAL,
  kIfcWindowPanelOperationEnum_SLIDINGVERTICAL,
  kIfcWindowPanelOperationEnum_REMOVABLECASEMENT,
  kIfcWindowPanelOperationEnum_FIXEDCASEMENT,
  kIfcWindowPanelOperationEnum_OTHEROPERATION,
  kIfcWindowPanelOperationEnum_NOTDEFINED,
  kIfcWindowPanelOperationEnum_unset
};
 
class IfcWindowPanelOperationEnum {
  IfcWindowPanelOperationEnum_ m_val;
public:
  IfcWindowPanelOperationEnum() : m_val(kIfcWindowPanelOperationEnum_unset) {};
  IfcWindowPanelOperationEnum(const IfcWindowPanelOperationEnum &other) : m_val(other.m_val) {};
  IfcWindowPanelOperationEnum(IfcWindowPanelOperationEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcWindowPanelOperationEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcWindowPanelOperationEnum_unset; };
  operator IfcWindowPanelOperationEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcWindowPanelOperationEnum& operator = (const IfcWindowPanelOperationEnum_ val) { if (val < kIfcWindowPanelOperationEnum_unset) m_val = val; else m_val = kIfcWindowPanelOperationEnum_unset; return *this; };
  bool operator == (const IfcWindowPanelOperationEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcWindowPanelOperationEnum &in);
IfcWindowPanelOperationEnum StrToIfcWindowPanelOperationEnum(OdAnsiString val);
enum IfcWindowPanelPositionEnum_
{
  kIfcWindowPanelPositionEnum_LEFT,
  kIfcWindowPanelPositionEnum_MIDDLE,
  kIfcWindowPanelPositionEnum_RIGHT,
  kIfcWindowPanelPositionEnum_BOTTOM,
  kIfcWindowPanelPositionEnum_TOP,
  kIfcWindowPanelPositionEnum_NOTDEFINED,
  kIfcWindowPanelPositionEnum_unset
};
 
class IfcWindowPanelPositionEnum {
  IfcWindowPanelPositionEnum_ m_val;
public:
  IfcWindowPanelPositionEnum() : m_val(kIfcWindowPanelPositionEnum_unset) {};
  IfcWindowPanelPositionEnum(const IfcWindowPanelPositionEnum &other) : m_val(other.m_val) {};
  IfcWindowPanelPositionEnum(IfcWindowPanelPositionEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcWindowPanelPositionEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcWindowPanelPositionEnum_unset; };
  operator IfcWindowPanelPositionEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcWindowPanelPositionEnum& operator = (const IfcWindowPanelPositionEnum_ val) { if (val < kIfcWindowPanelPositionEnum_unset) m_val = val; else m_val = kIfcWindowPanelPositionEnum_unset; return *this; };
  bool operator == (const IfcWindowPanelPositionEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcWindowPanelPositionEnum &in);
IfcWindowPanelPositionEnum StrToIfcWindowPanelPositionEnum(OdAnsiString val);
enum IfcWindowStyleConstructionEnum_
{
  kIfcWindowStyleConstructionEnum_ALUMINIUM,
  kIfcWindowStyleConstructionEnum_HIGH_GRADE_STEEL,
  kIfcWindowStyleConstructionEnum_STEEL,
  kIfcWindowStyleConstructionEnum_WOOD,
  kIfcWindowStyleConstructionEnum_ALUMINIUM_WOOD,
  kIfcWindowStyleConstructionEnum_PLASTIC,
  kIfcWindowStyleConstructionEnum_OTHER_CONSTRUCTION,
  kIfcWindowStyleConstructionEnum_NOTDEFINED,
  kIfcWindowStyleConstructionEnum_unset
};
 
class IfcWindowStyleConstructionEnum {
  IfcWindowStyleConstructionEnum_ m_val;
public:
  IfcWindowStyleConstructionEnum() : m_val(kIfcWindowStyleConstructionEnum_unset) {};
  IfcWindowStyleConstructionEnum(const IfcWindowStyleConstructionEnum &other) : m_val(other.m_val) {};
  IfcWindowStyleConstructionEnum(IfcWindowStyleConstructionEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcWindowStyleConstructionEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcWindowStyleConstructionEnum_unset; };
  operator IfcWindowStyleConstructionEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcWindowStyleConstructionEnum& operator = (const IfcWindowStyleConstructionEnum_ val) { if (val < kIfcWindowStyleConstructionEnum_unset) m_val = val; else m_val = kIfcWindowStyleConstructionEnum_unset; return *this; };
  bool operator == (const IfcWindowStyleConstructionEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcWindowStyleConstructionEnum &in);
IfcWindowStyleConstructionEnum StrToIfcWindowStyleConstructionEnum(OdAnsiString val);
enum IfcWindowStyleOperationEnum_
{
  kIfcWindowStyleOperationEnum_SINGLE_PANEL,
  kIfcWindowStyleOperationEnum_DOUBLE_PANEL_VERTICAL,
  kIfcWindowStyleOperationEnum_DOUBLE_PANEL_HORIZONTAL,
  kIfcWindowStyleOperationEnum_TRIPLE_PANEL_VERTICAL,
  kIfcWindowStyleOperationEnum_TRIPLE_PANEL_BOTTOM,
  kIfcWindowStyleOperationEnum_TRIPLE_PANEL_TOP,
  kIfcWindowStyleOperationEnum_TRIPLE_PANEL_LEFT,
  kIfcWindowStyleOperationEnum_TRIPLE_PANEL_RIGHT,
  kIfcWindowStyleOperationEnum_TRIPLE_PANEL_HORIZONTAL,
  kIfcWindowStyleOperationEnum_USERDEFINED,
  kIfcWindowStyleOperationEnum_NOTDEFINED,
  kIfcWindowStyleOperationEnum_unset
};
 
class IfcWindowStyleOperationEnum {
  IfcWindowStyleOperationEnum_ m_val;
public:
  IfcWindowStyleOperationEnum() : m_val(kIfcWindowStyleOperationEnum_unset) {};
  IfcWindowStyleOperationEnum(const IfcWindowStyleOperationEnum &other) : m_val(other.m_val) {};
  IfcWindowStyleOperationEnum(IfcWindowStyleOperationEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcWindowStyleOperationEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcWindowStyleOperationEnum_unset; };
  operator IfcWindowStyleOperationEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcWindowStyleOperationEnum& operator = (const IfcWindowStyleOperationEnum_ val) { if (val < kIfcWindowStyleOperationEnum_unset) m_val = val; else m_val = kIfcWindowStyleOperationEnum_unset; return *this; };
  bool operator == (const IfcWindowStyleOperationEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcWindowStyleOperationEnum &in);
IfcWindowStyleOperationEnum StrToIfcWindowStyleOperationEnum(OdAnsiString val);
enum IfcWorkControlTypeEnum_
{
  kIfcWorkControlTypeEnum_ACTUAL,
  kIfcWorkControlTypeEnum_BASELINE,
  kIfcWorkControlTypeEnum_PLANNED,
  kIfcWorkControlTypeEnum_USERDEFINED,
  kIfcWorkControlTypeEnum_NOTDEFINED,
  kIfcWorkControlTypeEnum_unset
};
 
class IfcWorkControlTypeEnum {
  IfcWorkControlTypeEnum_ m_val;
public:
  IfcWorkControlTypeEnum() : m_val(kIfcWorkControlTypeEnum_unset) {};
  IfcWorkControlTypeEnum(const IfcWorkControlTypeEnum &other) : m_val(other.m_val) {};
  IfcWorkControlTypeEnum(IfcWorkControlTypeEnum_ val) : m_val(val) {};
  int exists() const { return m_val != kIfcWorkControlTypeEnum_unset ? 1 : 0; };
  void nullify() { m_val = kIfcWorkControlTypeEnum_unset; };
  operator IfcWorkControlTypeEnum_() const { return m_val; };
  operator unsigned long () const { return (unsigned long)m_val; };
  IfcWorkControlTypeEnum& operator = (const IfcWorkControlTypeEnum_ val) { if (val < kIfcWorkControlTypeEnum_unset) m_val = val; else m_val = kIfcWorkControlTypeEnum_unset; return *this; };
  bool operator == (const IfcWorkControlTypeEnum &other) const { return m_val == other.m_val; };
  OdAnsiString toStr();
 
};
 
bool operator>> (const OdRxValue &out, IfcWorkControlTypeEnum &in);
IfcWorkControlTypeEnum StrToIfcWorkControlTypeEnum(OdAnsiString val);
 
} // namespace
 
#endif // _IFC2X3_ENUM_2x3_H