d2/da3/_ifc4_enum_8h_source.html

// 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 _IFC4_ENUM_4_H

#define _IFC4_ENUM_4_H


using namespace OdIfc;


namespace OdIfc4 {


typedef OdDAI::OdLogical Logical;

typedef OdDAI::OdLogical IfcLogical;


enum IfcActionRequestTypeEnum_

{

  kIfcActionRequestTypeEnum_EMAIL,

  kIfcActionRequestTypeEnum_FAX,

  kIfcActionRequestTypeEnum_PHONE,

  kIfcActionRequestTypeEnum_POST,

  kIfcActionRequestTypeEnum_VERBAL,

  kIfcActionRequestTypeEnum_USERDEFINED,

  kIfcActionRequestTypeEnum_NOTDEFINED,

  kIfcActionRequestTypeEnum_unset

};


class IfcActionRequestTypeEnum {

  IfcActionRequestTypeEnum_ m_val;

public:

  IfcActionRequestTypeEnum() : m_val(kIfcActionRequestTypeEnum_unset) {};

  IfcActionRequestTypeEnum(const IfcActionRequestTypeEnum &other) : m_val(other.m_val) {};

  IfcActionRequestTypeEnum(IfcActionRequestTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcActionRequestTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcActionRequestTypeEnum_unset; };

  operator IfcActionRequestTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcActionRequestTypeEnum& operator = (const IfcActionRequestTypeEnum_ val) { if (val < kIfcActionRequestTypeEnum_unset) m_val = val; else m_val = kIfcActionRequestTypeEnum_unset; return *this; };

  bool operator == (const IfcActionRequestTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcActionRequestTypeEnum &in);

IfcActionRequestTypeEnum StrToIfcActionRequestTypeEnum(OdAnsiString val);

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 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_DIFFUSER,

  kIfcAirTerminalTypeEnum_GRILLE,

  kIfcAirTerminalTypeEnum_LOUVRE,

  kIfcAirTerminalTypeEnum_REGISTER,

  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 IfcAudioVisualApplianceTypeEnum_

{

  kIfcAudioVisualApplianceTypeEnum_AMPLIFIER,

  kIfcAudioVisualApplianceTypeEnum_CAMERA,

  kIfcAudioVisualApplianceTypeEnum_DISPLAY,

  kIfcAudioVisualApplianceTypeEnum_MICROPHONE,

  kIfcAudioVisualApplianceTypeEnum_PLAYER,

  kIfcAudioVisualApplianceTypeEnum_PROJECTOR,

  kIfcAudioVisualApplianceTypeEnum_RECEIVER,

  kIfcAudioVisualApplianceTypeEnum_SPEAKER,

  kIfcAudioVisualApplianceTypeEnum_SWITCHER,

  kIfcAudioVisualApplianceTypeEnum_TELEPHONE,

  kIfcAudioVisualApplianceTypeEnum_TUNER,

  kIfcAudioVisualApplianceTypeEnum_USERDEFINED,

  kIfcAudioVisualApplianceTypeEnum_NOTDEFINED,

  kIfcAudioVisualApplianceTypeEnum_unset

};


class IfcAudioVisualApplianceTypeEnum {

  IfcAudioVisualApplianceTypeEnum_ m_val;

public:

  IfcAudioVisualApplianceTypeEnum() : m_val(kIfcAudioVisualApplianceTypeEnum_unset) {};

  IfcAudioVisualApplianceTypeEnum(const IfcAudioVisualApplianceTypeEnum &other) : m_val(other.m_val) {};

  IfcAudioVisualApplianceTypeEnum(IfcAudioVisualApplianceTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcAudioVisualApplianceTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcAudioVisualApplianceTypeEnum_unset; };

  operator IfcAudioVisualApplianceTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcAudioVisualApplianceTypeEnum& operator = (const IfcAudioVisualApplianceTypeEnum_ val) { if (val < kIfcAudioVisualApplianceTypeEnum_unset) m_val = val; else m_val = kIfcAudioVisualApplianceTypeEnum_unset; return *this; };

  bool operator == (const IfcAudioVisualApplianceTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcAudioVisualApplianceTypeEnum &in);

IfcAudioVisualApplianceTypeEnum StrToIfcAudioVisualApplianceTypeEnum(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 IfcBSplineSurfaceForm_

{

  kIfcBSplineSurfaceForm_PLANE_SURF,

  kIfcBSplineSurfaceForm_CYLINDRICAL_SURF,

  kIfcBSplineSurfaceForm_CONICAL_SURF,

  kIfcBSplineSurfaceForm_SPHERICAL_SURF,

  kIfcBSplineSurfaceForm_TOROIDAL_SURF,

  kIfcBSplineSurfaceForm_SURF_OF_REVOLUTION,

  kIfcBSplineSurfaceForm_RULED_SURF,

  kIfcBSplineSurfaceForm_GENERALISED_CONE,

  kIfcBSplineSurfaceForm_QUADRIC_SURF,

  kIfcBSplineSurfaceForm_SURF_OF_LINEAR_EXTRUSION,

  kIfcBSplineSurfaceForm_UNSPECIFIED,

  kIfcBSplineSurfaceForm_unset

};


class IfcBSplineSurfaceForm {

  IfcBSplineSurfaceForm_ m_val;

public:

  IfcBSplineSurfaceForm() : m_val(kIfcBSplineSurfaceForm_unset) {};

  IfcBSplineSurfaceForm(const IfcBSplineSurfaceForm &other) : m_val(other.m_val) {};

  IfcBSplineSurfaceForm(IfcBSplineSurfaceForm_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcBSplineSurfaceForm_unset ? 1 : 0; };

  void nullify() { m_val = kIfcBSplineSurfaceForm_unset; };

  operator IfcBSplineSurfaceForm_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcBSplineSurfaceForm& operator = (const IfcBSplineSurfaceForm_ val) { if (val < kIfcBSplineSurfaceForm_unset) m_val = val; else m_val = kIfcBSplineSurfaceForm_unset; return *this; };

  bool operator == (const IfcBSplineSurfaceForm &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcBSplineSurfaceForm &in);

IfcBSplineSurfaceForm StrToIfcBSplineSurfaceForm(OdAnsiString val);

enum IfcBeamTypeEnum_

{

  kIfcBeamTypeEnum_BEAM,

  kIfcBeamTypeEnum_JOIST,

  kIfcBeamTypeEnum_HOLLOWCORE,

  kIfcBeamTypeEnum_LINTEL,

  kIfcBeamTypeEnum_SPANDREL,

  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_INCLUDES,

  kIfcBenchmarkEnum_NOTINCLUDES,

  kIfcBenchmarkEnum_INCLUDEDIN,

  kIfcBenchmarkEnum_NOTINCLUDEDIN,

  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 IfcBuildingElementPartTypeEnum_

{

  kIfcBuildingElementPartTypeEnum_INSULATION,

  kIfcBuildingElementPartTypeEnum_PRECASTPANEL,

  kIfcBuildingElementPartTypeEnum_USERDEFINED,

  kIfcBuildingElementPartTypeEnum_NOTDEFINED,

  kIfcBuildingElementPartTypeEnum_unset

};


class IfcBuildingElementPartTypeEnum {

  IfcBuildingElementPartTypeEnum_ m_val;

public:

  IfcBuildingElementPartTypeEnum() : m_val(kIfcBuildingElementPartTypeEnum_unset) {};

  IfcBuildingElementPartTypeEnum(const IfcBuildingElementPartTypeEnum &other) : m_val(other.m_val) {};

  IfcBuildingElementPartTypeEnum(IfcBuildingElementPartTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcBuildingElementPartTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcBuildingElementPartTypeEnum_unset; };

  operator IfcBuildingElementPartTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcBuildingElementPartTypeEnum& operator = (const IfcBuildingElementPartTypeEnum_ val) { if (val < kIfcBuildingElementPartTypeEnum_unset) m_val = val; else m_val = kIfcBuildingElementPartTypeEnum_unset; return *this; };

  bool operator == (const IfcBuildingElementPartTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcBuildingElementPartTypeEnum &in);

IfcBuildingElementPartTypeEnum StrToIfcBuildingElementPartTypeEnum(OdAnsiString val);

enum IfcBuildingElementProxyTypeEnum_

{

  kIfcBuildingElementProxyTypeEnum_COMPLEX,

  kIfcBuildingElementProxyTypeEnum_ELEMENT,

  kIfcBuildingElementProxyTypeEnum_PARTIAL,

  kIfcBuildingElementProxyTypeEnum_PROVISIONFORVOID,

  kIfcBuildingElementProxyTypeEnum_PROVISIONFORSPACE,

  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 IfcBuildingSystemTypeEnum_

{

  kIfcBuildingSystemTypeEnum_FENESTRATION,

  kIfcBuildingSystemTypeEnum_FOUNDATION,

  kIfcBuildingSystemTypeEnum_LOADBEARING,

  kIfcBuildingSystemTypeEnum_OUTERSHELL,

  kIfcBuildingSystemTypeEnum_SHADING,

  kIfcBuildingSystemTypeEnum_TRANSPORT,

  kIfcBuildingSystemTypeEnum_USERDEFINED,

  kIfcBuildingSystemTypeEnum_NOTDEFINED,

  kIfcBuildingSystemTypeEnum_unset

};


class IfcBuildingSystemTypeEnum {

  IfcBuildingSystemTypeEnum_ m_val;

public:

  IfcBuildingSystemTypeEnum() : m_val(kIfcBuildingSystemTypeEnum_unset) {};

  IfcBuildingSystemTypeEnum(const IfcBuildingSystemTypeEnum &other) : m_val(other.m_val) {};

  IfcBuildingSystemTypeEnum(IfcBuildingSystemTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcBuildingSystemTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcBuildingSystemTypeEnum_unset; };

  operator IfcBuildingSystemTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcBuildingSystemTypeEnum& operator = (const IfcBuildingSystemTypeEnum_ val) { if (val < kIfcBuildingSystemTypeEnum_unset) m_val = val; else m_val = kIfcBuildingSystemTypeEnum_unset; return *this; };

  bool operator == (const IfcBuildingSystemTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcBuildingSystemTypeEnum &in);

IfcBuildingSystemTypeEnum StrToIfcBuildingSystemTypeEnum(OdAnsiString val);

enum IfcBurnerTypeEnum_

{

  kIfcBurnerTypeEnum_USERDEFINED,

  kIfcBurnerTypeEnum_NOTDEFINED,

  kIfcBurnerTypeEnum_unset

};


class IfcBurnerTypeEnum {

  IfcBurnerTypeEnum_ m_val;

public:

  IfcBurnerTypeEnum() : m_val(kIfcBurnerTypeEnum_unset) {};

  IfcBurnerTypeEnum(const IfcBurnerTypeEnum &other) : m_val(other.m_val) {};

  IfcBurnerTypeEnum(IfcBurnerTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcBurnerTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcBurnerTypeEnum_unset; };

  operator IfcBurnerTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcBurnerTypeEnum& operator = (const IfcBurnerTypeEnum_ val) { if (val < kIfcBurnerTypeEnum_unset) m_val = val; else m_val = kIfcBurnerTypeEnum_unset; return *this; };

  bool operator == (const IfcBurnerTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcBurnerTypeEnum &in);

IfcBurnerTypeEnum StrToIfcBurnerTypeEnum(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 IfcCableFittingTypeEnum_

{

  kIfcCableFittingTypeEnum_CONNECTOR,

  kIfcCableFittingTypeEnum_ENTRY,

  kIfcCableFittingTypeEnum_EXIT,

  kIfcCableFittingTypeEnum_JUNCTION,

  kIfcCableFittingTypeEnum_TRANSITION,

  kIfcCableFittingTypeEnum_USERDEFINED,

  kIfcCableFittingTypeEnum_NOTDEFINED,

  kIfcCableFittingTypeEnum_unset

};


class IfcCableFittingTypeEnum {

  IfcCableFittingTypeEnum_ m_val;

public:

  IfcCableFittingTypeEnum() : m_val(kIfcCableFittingTypeEnum_unset) {};

  IfcCableFittingTypeEnum(const IfcCableFittingTypeEnum &other) : m_val(other.m_val) {};

  IfcCableFittingTypeEnum(IfcCableFittingTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcCableFittingTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcCableFittingTypeEnum_unset; };

  operator IfcCableFittingTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcCableFittingTypeEnum& operator = (const IfcCableFittingTypeEnum_ val) { if (val < kIfcCableFittingTypeEnum_unset) m_val = val; else m_val = kIfcCableFittingTypeEnum_unset; return *this; };

  bool operator == (const IfcCableFittingTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcCableFittingTypeEnum &in);

IfcCableFittingTypeEnum StrToIfcCableFittingTypeEnum(OdAnsiString val);

enum IfcCableSegmentTypeEnum_

{

  kIfcCableSegmentTypeEnum_BUSBARSEGMENT,

  kIfcCableSegmentTypeEnum_CABLESEGMENT,

  kIfcCableSegmentTypeEnum_CONDUCTORSEGMENT,

  kIfcCableSegmentTypeEnum_CORESEGMENT,

  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_NOTDEFINED,

  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 IfcChimneyTypeEnum_

{

  kIfcChimneyTypeEnum_USERDEFINED,

  kIfcChimneyTypeEnum_NOTDEFINED,

  kIfcChimneyTypeEnum_unset

};


class IfcChimneyTypeEnum {

  IfcChimneyTypeEnum_ m_val;

public:

  IfcChimneyTypeEnum() : m_val(kIfcChimneyTypeEnum_unset) {};

  IfcChimneyTypeEnum(const IfcChimneyTypeEnum &other) : m_val(other.m_val) {};

  IfcChimneyTypeEnum(IfcChimneyTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcChimneyTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcChimneyTypeEnum_unset; };

  operator IfcChimneyTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcChimneyTypeEnum& operator = (const IfcChimneyTypeEnum_ val) { if (val < kIfcChimneyTypeEnum_unset) m_val = val; else m_val = kIfcChimneyTypeEnum_unset; return *this; };

  bool operator == (const IfcChimneyTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcChimneyTypeEnum &in);

IfcChimneyTypeEnum StrToIfcChimneyTypeEnum(OdAnsiString val);

enum IfcCoilTypeEnum_

{

  kIfcCoilTypeEnum_DXCOOLINGCOIL,

  kIfcCoilTypeEnum_ELECTRICHEATINGCOIL,

  kIfcCoilTypeEnum_GASHEATINGCOIL,

  kIfcCoilTypeEnum_HYDRONICCOIL,

  kIfcCoilTypeEnum_STEAMHEATINGCOIL,

  kIfcCoilTypeEnum_WATERCOOLINGCOIL,

  kIfcCoilTypeEnum_WATERHEATINGCOIL,

  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_PILASTER,

  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 IfcCommunicationsApplianceTypeEnum_

{

  kIfcCommunicationsApplianceTypeEnum_ANTENNA,

  kIfcCommunicationsApplianceTypeEnum_COMPUTER,

  kIfcCommunicationsApplianceTypeEnum_FAX,

  kIfcCommunicationsApplianceTypeEnum_GATEWAY,

  kIfcCommunicationsApplianceTypeEnum_MODEM,

  kIfcCommunicationsApplianceTypeEnum_NETWORKAPPLIANCE,

  kIfcCommunicationsApplianceTypeEnum_NETWORKBRIDGE,

  kIfcCommunicationsApplianceTypeEnum_NETWORKHUB,

  kIfcCommunicationsApplianceTypeEnum_PRINTER,

  kIfcCommunicationsApplianceTypeEnum_REPEATER,

  kIfcCommunicationsApplianceTypeEnum_ROUTER,

  kIfcCommunicationsApplianceTypeEnum_SCANNER,

  kIfcCommunicationsApplianceTypeEnum_USERDEFINED,

  kIfcCommunicationsApplianceTypeEnum_NOTDEFINED,

  kIfcCommunicationsApplianceTypeEnum_unset

};


class IfcCommunicationsApplianceTypeEnum {

  IfcCommunicationsApplianceTypeEnum_ m_val;

public:

  IfcCommunicationsApplianceTypeEnum() : m_val(kIfcCommunicationsApplianceTypeEnum_unset) {};

  IfcCommunicationsApplianceTypeEnum(const IfcCommunicationsApplianceTypeEnum &other) : m_val(other.m_val) {};

  IfcCommunicationsApplianceTypeEnum(IfcCommunicationsApplianceTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcCommunicationsApplianceTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcCommunicationsApplianceTypeEnum_unset; };

  operator IfcCommunicationsApplianceTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcCommunicationsApplianceTypeEnum& operator = (const IfcCommunicationsApplianceTypeEnum_ val) { if (val < kIfcCommunicationsApplianceTypeEnum_unset) m_val = val; else m_val = kIfcCommunicationsApplianceTypeEnum_unset; return *this; };

  bool operator == (const IfcCommunicationsApplianceTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcCommunicationsApplianceTypeEnum &in);

IfcCommunicationsApplianceTypeEnum StrToIfcCommunicationsApplianceTypeEnum(OdAnsiString val);

enum IfcComplexPropertyTemplateTypeEnum_

{

  kIfcComplexPropertyTemplateTypeEnum_P_COMPLEX,

  kIfcComplexPropertyTemplateTypeEnum_Q_COMPLEX,

  kIfcComplexPropertyTemplateTypeEnum_unset

};


class IfcComplexPropertyTemplateTypeEnum {

  IfcComplexPropertyTemplateTypeEnum_ m_val;

public:

  IfcComplexPropertyTemplateTypeEnum() : m_val(kIfcComplexPropertyTemplateTypeEnum_unset) {};

  IfcComplexPropertyTemplateTypeEnum(const IfcComplexPropertyTemplateTypeEnum &other) : m_val(other.m_val) {};

  IfcComplexPropertyTemplateTypeEnum(IfcComplexPropertyTemplateTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcComplexPropertyTemplateTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcComplexPropertyTemplateTypeEnum_unset; };

  operator IfcComplexPropertyTemplateTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcComplexPropertyTemplateTypeEnum& operator = (const IfcComplexPropertyTemplateTypeEnum_ val) { if (val < kIfcComplexPropertyTemplateTypeEnum_unset) m_val = val; else m_val = kIfcComplexPropertyTemplateTypeEnum_unset; return *this; };

  bool operator == (const IfcComplexPropertyTemplateTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcComplexPropertyTemplateTypeEnum &in);

IfcComplexPropertyTemplateTypeEnum StrToIfcComplexPropertyTemplateTypeEnum(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_AIRCOOLED,

  kIfcCondenserTypeEnum_EVAPORATIVECOOLED,

  kIfcCondenserTypeEnum_WATERCOOLED,

  kIfcCondenserTypeEnum_WATERCOOLEDBRAZEDPLATE,

  kIfcCondenserTypeEnum_WATERCOOLEDSHELLCOIL,

  kIfcCondenserTypeEnum_WATERCOOLEDSHELLTUBE,

  kIfcCondenserTypeEnum_WATERCOOLEDTUBEINTUBE,

  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 IfcConstructionEquipmentResourceTypeEnum_

{

  kIfcConstructionEquipmentResourceTypeEnum_DEMOLISHING,

  kIfcConstructionEquipmentResourceTypeEnum_EARTHMOVING,

  kIfcConstructionEquipmentResourceTypeEnum_ERECTING,

  kIfcConstructionEquipmentResourceTypeEnum_HEATING,

  kIfcConstructionEquipmentResourceTypeEnum_LIGHTING,

  kIfcConstructionEquipmentResourceTypeEnum_PAVING,

  kIfcConstructionEquipmentResourceTypeEnum_PUMPING,

  kIfcConstructionEquipmentResourceTypeEnum_TRANSPORTING,

  kIfcConstructionEquipmentResourceTypeEnum_USERDEFINED,

  kIfcConstructionEquipmentResourceTypeEnum_NOTDEFINED,

  kIfcConstructionEquipmentResourceTypeEnum_unset

};


class IfcConstructionEquipmentResourceTypeEnum {

  IfcConstructionEquipmentResourceTypeEnum_ m_val;

public:

  IfcConstructionEquipmentResourceTypeEnum() : m_val(kIfcConstructionEquipmentResourceTypeEnum_unset) {};

  IfcConstructionEquipmentResourceTypeEnum(const IfcConstructionEquipmentResourceTypeEnum &other) : m_val(other.m_val) {};

  IfcConstructionEquipmentResourceTypeEnum(IfcConstructionEquipmentResourceTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcConstructionEquipmentResourceTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcConstructionEquipmentResourceTypeEnum_unset; };

  operator IfcConstructionEquipmentResourceTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcConstructionEquipmentResourceTypeEnum& operator = (const IfcConstructionEquipmentResourceTypeEnum_ val) { if (val < kIfcConstructionEquipmentResourceTypeEnum_unset) m_val = val; else m_val = kIfcConstructionEquipmentResourceTypeEnum_unset; return *this; };

  bool operator == (const IfcConstructionEquipmentResourceTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcConstructionEquipmentResourceTypeEnum &in);

IfcConstructionEquipmentResourceTypeEnum StrToIfcConstructionEquipmentResourceTypeEnum(OdAnsiString val);

enum IfcConstructionMaterialResourceTypeEnum_

{

  kIfcConstructionMaterialResourceTypeEnum_AGGREGATES,

  kIfcConstructionMaterialResourceTypeEnum_CONCRETE,

  kIfcConstructionMaterialResourceTypeEnum_DRYWALL,

  kIfcConstructionMaterialResourceTypeEnum_FUEL,

  kIfcConstructionMaterialResourceTypeEnum_GYPSUM,

  kIfcConstructionMaterialResourceTypeEnum_MASONRY,

  kIfcConstructionMaterialResourceTypeEnum_METAL,

  kIfcConstructionMaterialResourceTypeEnum_PLASTIC,

  kIfcConstructionMaterialResourceTypeEnum_WOOD,

  kIfcConstructionMaterialResourceTypeEnum_NOTDEFINED,

  kIfcConstructionMaterialResourceTypeEnum_USERDEFINED,

  kIfcConstructionMaterialResourceTypeEnum_unset

};


class IfcConstructionMaterialResourceTypeEnum {

  IfcConstructionMaterialResourceTypeEnum_ m_val;

public:

  IfcConstructionMaterialResourceTypeEnum() : m_val(kIfcConstructionMaterialResourceTypeEnum_unset) {};

  IfcConstructionMaterialResourceTypeEnum(const IfcConstructionMaterialResourceTypeEnum &other) : m_val(other.m_val) {};

  IfcConstructionMaterialResourceTypeEnum(IfcConstructionMaterialResourceTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcConstructionMaterialResourceTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcConstructionMaterialResourceTypeEnum_unset; };

  operator IfcConstructionMaterialResourceTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcConstructionMaterialResourceTypeEnum& operator = (const IfcConstructionMaterialResourceTypeEnum_ val) { if (val < kIfcConstructionMaterialResourceTypeEnum_unset) m_val = val; else m_val = kIfcConstructionMaterialResourceTypeEnum_unset; return *this; };

  bool operator == (const IfcConstructionMaterialResourceTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcConstructionMaterialResourceTypeEnum &in);

IfcConstructionMaterialResourceTypeEnum StrToIfcConstructionMaterialResourceTypeEnum(OdAnsiString val);

enum IfcConstructionProductResourceTypeEnum_

{

  kIfcConstructionProductResourceTypeEnum_ASSEMBLY,

  kIfcConstructionProductResourceTypeEnum_FORMWORK,

  kIfcConstructionProductResourceTypeEnum_USERDEFINED,

  kIfcConstructionProductResourceTypeEnum_NOTDEFINED,

  kIfcConstructionProductResourceTypeEnum_unset

};


class IfcConstructionProductResourceTypeEnum {

  IfcConstructionProductResourceTypeEnum_ m_val;

public:

  IfcConstructionProductResourceTypeEnum() : m_val(kIfcConstructionProductResourceTypeEnum_unset) {};

  IfcConstructionProductResourceTypeEnum(const IfcConstructionProductResourceTypeEnum &other) : m_val(other.m_val) {};

  IfcConstructionProductResourceTypeEnum(IfcConstructionProductResourceTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcConstructionProductResourceTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcConstructionProductResourceTypeEnum_unset; };

  operator IfcConstructionProductResourceTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcConstructionProductResourceTypeEnum& operator = (const IfcConstructionProductResourceTypeEnum_ val) { if (val < kIfcConstructionProductResourceTypeEnum_unset) m_val = val; else m_val = kIfcConstructionProductResourceTypeEnum_unset; return *this; };

  bool operator == (const IfcConstructionProductResourceTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcConstructionProductResourceTypeEnum &in);

IfcConstructionProductResourceTypeEnum StrToIfcConstructionProductResourceTypeEnum(OdAnsiString val);

enum IfcControllerTypeEnum_

{

  kIfcControllerTypeEnum_FLOATING,

  kIfcControllerTypeEnum_PROGRAMMABLE,

  kIfcControllerTypeEnum_PROPORTIONAL,

  kIfcControllerTypeEnum_MULTIPOSITION,

  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 IfcCostItemTypeEnum_

{

  kIfcCostItemTypeEnum_USERDEFINED,

  kIfcCostItemTypeEnum_NOTDEFINED,

  kIfcCostItemTypeEnum_unset

};


class IfcCostItemTypeEnum {

  IfcCostItemTypeEnum_ m_val;

public:

  IfcCostItemTypeEnum() : m_val(kIfcCostItemTypeEnum_unset) {};

  IfcCostItemTypeEnum(const IfcCostItemTypeEnum &other) : m_val(other.m_val) {};

  IfcCostItemTypeEnum(IfcCostItemTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcCostItemTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcCostItemTypeEnum_unset; };

  operator IfcCostItemTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcCostItemTypeEnum& operator = (const IfcCostItemTypeEnum_ val) { if (val < kIfcCostItemTypeEnum_unset) m_val = val; else m_val = kIfcCostItemTypeEnum_unset; return *this; };

  bool operator == (const IfcCostItemTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcCostItemTypeEnum &in);

IfcCostItemTypeEnum StrToIfcCostItemTypeEnum(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_MOLDING,

  kIfcCoveringTypeEnum_SKIRTINGBOARD,

  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 IfcCrewResourceTypeEnum_

{

  kIfcCrewResourceTypeEnum_OFFICE,

  kIfcCrewResourceTypeEnum_SITE,

  kIfcCrewResourceTypeEnum_USERDEFINED,

  kIfcCrewResourceTypeEnum_NOTDEFINED,

  kIfcCrewResourceTypeEnum_unset

};


class IfcCrewResourceTypeEnum {

  IfcCrewResourceTypeEnum_ m_val;

public:

  IfcCrewResourceTypeEnum() : m_val(kIfcCrewResourceTypeEnum_unset) {};

  IfcCrewResourceTypeEnum(const IfcCrewResourceTypeEnum &other) : m_val(other.m_val) {};

  IfcCrewResourceTypeEnum(IfcCrewResourceTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcCrewResourceTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcCrewResourceTypeEnum_unset; };

  operator IfcCrewResourceTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcCrewResourceTypeEnum& operator = (const IfcCrewResourceTypeEnum_ val) { if (val < kIfcCrewResourceTypeEnum_unset) m_val = val; else m_val = kIfcCrewResourceTypeEnum_unset; return *this; };

  bool operator == (const IfcCrewResourceTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcCrewResourceTypeEnum &in);

IfcCrewResourceTypeEnum StrToIfcCrewResourceTypeEnum(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 IfcCurveInterpolationEnum_

{

  kIfcCurveInterpolationEnum_LINEAR,

  kIfcCurveInterpolationEnum_LOG_LINEAR,

  kIfcCurveInterpolationEnum_LOG_LOG,

  kIfcCurveInterpolationEnum_NOTDEFINED,

  kIfcCurveInterpolationEnum_unset

};


class IfcCurveInterpolationEnum {

  IfcCurveInterpolationEnum_ m_val;

public:

  IfcCurveInterpolationEnum() : m_val(kIfcCurveInterpolationEnum_unset) {};

  IfcCurveInterpolationEnum(const IfcCurveInterpolationEnum &other) : m_val(other.m_val) {};

  IfcCurveInterpolationEnum(IfcCurveInterpolationEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcCurveInterpolationEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcCurveInterpolationEnum_unset; };

  operator IfcCurveInterpolationEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcCurveInterpolationEnum& operator = (const IfcCurveInterpolationEnum_ val) { if (val < kIfcCurveInterpolationEnum_unset) m_val = val; else m_val = kIfcCurveInterpolationEnum_unset; return *this; };

  bool operator == (const IfcCurveInterpolationEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcCurveInterpolationEnum &in);

IfcCurveInterpolationEnum StrToIfcCurveInterpolationEnum(OdAnsiString val);

enum IfcDamperTypeEnum_

{

  kIfcDamperTypeEnum_BACKDRAFTDAMPER,

  kIfcDamperTypeEnum_BALANCINGDAMPER,

  kIfcDamperTypeEnum_BLASTDAMPER,

  kIfcDamperTypeEnum_CONTROLDAMPER,

  kIfcDamperTypeEnum_FIREDAMPER,

  kIfcDamperTypeEnum_FIRESMOKEDAMPER,

  kIfcDamperTypeEnum_FUMEHOODEXHAUST,

  kIfcDamperTypeEnum_GRAVITYDAMPER,

  kIfcDamperTypeEnum_GRAVITYRELIEFDAMPER,

  kIfcDamperTypeEnum_RELIEFDAMPER,

  kIfcDamperTypeEnum_SMOKEDAMPER,

  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_AREADENSITYUNIT,

  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_SOUNDPOWERLEVELUNIT,

  kIfcDerivedUnitEnum_SOUNDPOWERUNIT,

  kIfcDerivedUnitEnum_SOUNDPRESSURELEVELUNIT,

  kIfcDerivedUnitEnum_SOUNDPRESSUREUNIT,

  kIfcDerivedUnitEnum_TEMPERATUREGRADIENTUNIT,

  kIfcDerivedUnitEnum_TEMPERATURERATEOFCHANGEUNIT,

  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 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 IfcDiscreteAccessoryTypeEnum_

{

  kIfcDiscreteAccessoryTypeEnum_ANCHORPLATE,

  kIfcDiscreteAccessoryTypeEnum_BRACKET,

  kIfcDiscreteAccessoryTypeEnum_SHOE,

  kIfcDiscreteAccessoryTypeEnum_USERDEFINED,

  kIfcDiscreteAccessoryTypeEnum_NOTDEFINED,

  kIfcDiscreteAccessoryTypeEnum_unset

};


class IfcDiscreteAccessoryTypeEnum {

  IfcDiscreteAccessoryTypeEnum_ m_val;

public:

  IfcDiscreteAccessoryTypeEnum() : m_val(kIfcDiscreteAccessoryTypeEnum_unset) {};

  IfcDiscreteAccessoryTypeEnum(const IfcDiscreteAccessoryTypeEnum &other) : m_val(other.m_val) {};

  IfcDiscreteAccessoryTypeEnum(IfcDiscreteAccessoryTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcDiscreteAccessoryTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcDiscreteAccessoryTypeEnum_unset; };

  operator IfcDiscreteAccessoryTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcDiscreteAccessoryTypeEnum& operator = (const IfcDiscreteAccessoryTypeEnum_ val) { if (val < kIfcDiscreteAccessoryTypeEnum_unset) m_val = val; else m_val = kIfcDiscreteAccessoryTypeEnum_unset; return *this; };

  bool operator == (const IfcDiscreteAccessoryTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcDiscreteAccessoryTypeEnum &in);

IfcDiscreteAccessoryTypeEnum StrToIfcDiscreteAccessoryTypeEnum(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 IfcDistributionPortTypeEnum_

{

  kIfcDistributionPortTypeEnum_CABLE,

  kIfcDistributionPortTypeEnum_CABLECARRIER,

  kIfcDistributionPortTypeEnum_DUCT,

  kIfcDistributionPortTypeEnum_PIPE,

  kIfcDistributionPortTypeEnum_USERDEFINED,

  kIfcDistributionPortTypeEnum_NOTDEFINED,

  kIfcDistributionPortTypeEnum_unset

};


class IfcDistributionPortTypeEnum {

  IfcDistributionPortTypeEnum_ m_val;

public:

  IfcDistributionPortTypeEnum() : m_val(kIfcDistributionPortTypeEnum_unset) {};

  IfcDistributionPortTypeEnum(const IfcDistributionPortTypeEnum &other) : m_val(other.m_val) {};

  IfcDistributionPortTypeEnum(IfcDistributionPortTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcDistributionPortTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcDistributionPortTypeEnum_unset; };

  operator IfcDistributionPortTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcDistributionPortTypeEnum& operator = (const IfcDistributionPortTypeEnum_ val) { if (val < kIfcDistributionPortTypeEnum_unset) m_val = val; else m_val = kIfcDistributionPortTypeEnum_unset; return *this; };

  bool operator == (const IfcDistributionPortTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcDistributionPortTypeEnum &in);

IfcDistributionPortTypeEnum StrToIfcDistributionPortTypeEnum(OdAnsiString val);

enum IfcDistributionSystemEnum_

{

  kIfcDistributionSystemEnum_AIRCONDITIONING,

  kIfcDistributionSystemEnum_AUDIOVISUAL,

  kIfcDistributionSystemEnum_CHEMICAL,

  kIfcDistributionSystemEnum_CHILLEDWATER,

  kIfcDistributionSystemEnum_COMMUNICATION,

  kIfcDistributionSystemEnum_COMPRESSEDAIR,

  kIfcDistributionSystemEnum_CONDENSERWATER,

  kIfcDistributionSystemEnum_CONTROL,

  kIfcDistributionSystemEnum_CONVEYING,

  kIfcDistributionSystemEnum_DATA,

  kIfcDistributionSystemEnum_DISPOSAL,

  kIfcDistributionSystemEnum_DOMESTICCOLDWATER,

  kIfcDistributionSystemEnum_DOMESTICHOTWATER,

  kIfcDistributionSystemEnum_DRAINAGE,

  kIfcDistributionSystemEnum_EARTHING,

  kIfcDistributionSystemEnum_ELECTRICAL,

  kIfcDistributionSystemEnum_ELECTROACOUSTIC,

  kIfcDistributionSystemEnum_EXHAUST,

  kIfcDistributionSystemEnum_FIREPROTECTION,

  kIfcDistributionSystemEnum_FUEL,

  kIfcDistributionSystemEnum_GAS,

  kIfcDistributionSystemEnum_HAZARDOUS,

  kIfcDistributionSystemEnum_HEATING,

  kIfcDistributionSystemEnum_LIGHTING,

  kIfcDistributionSystemEnum_LIGHTNINGPROTECTION,

  kIfcDistributionSystemEnum_MUNICIPALSOLIDWASTE,

  kIfcDistributionSystemEnum_OIL,

  kIfcDistributionSystemEnum_OPERATIONAL,

  kIfcDistributionSystemEnum_POWERGENERATION,

  kIfcDistributionSystemEnum_RAINWATER,

  kIfcDistributionSystemEnum_REFRIGERATION,

  kIfcDistributionSystemEnum_SECURITY,

  kIfcDistributionSystemEnum_SEWAGE,

  kIfcDistributionSystemEnum_SIGNAL,

  kIfcDistributionSystemEnum_STORMWATER,

  kIfcDistributionSystemEnum_TELEPHONE,

  kIfcDistributionSystemEnum_TV,

  kIfcDistributionSystemEnum_VACUUM,

  kIfcDistributionSystemEnum_VENT,

  kIfcDistributionSystemEnum_VENTILATION,

  kIfcDistributionSystemEnum_WASTEWATER,

  kIfcDistributionSystemEnum_WATERSUPPLY,

  kIfcDistributionSystemEnum_USERDEFINED,

  kIfcDistributionSystemEnum_NOTDEFINED,

  kIfcDistributionSystemEnum_unset

};


class IfcDistributionSystemEnum {

  IfcDistributionSystemEnum_ m_val;

public:

  IfcDistributionSystemEnum() : m_val(kIfcDistributionSystemEnum_unset) {};

  IfcDistributionSystemEnum(const IfcDistributionSystemEnum &other) : m_val(other.m_val) {};

  IfcDistributionSystemEnum(IfcDistributionSystemEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcDistributionSystemEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcDistributionSystemEnum_unset; };

  operator IfcDistributionSystemEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcDistributionSystemEnum& operator = (const IfcDistributionSystemEnum_ val) { if (val < kIfcDistributionSystemEnum_unset) m_val = val; else m_val = kIfcDistributionSystemEnum_unset; return *this; };

  bool operator == (const IfcDistributionSystemEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcDistributionSystemEnum &in);

IfcDistributionSystemEnum StrToIfcDistributionSystemEnum(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_FIXEDPANEL,

  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 IfcDoorTypeEnum_

{

  kIfcDoorTypeEnum_DOOR,

  kIfcDoorTypeEnum_GATE,

  kIfcDoorTypeEnum_TRAPDOOR,

  kIfcDoorTypeEnum_USERDEFINED,

  kIfcDoorTypeEnum_NOTDEFINED,

  kIfcDoorTypeEnum_unset

};


class IfcDoorTypeEnum {

  IfcDoorTypeEnum_ m_val;

public:

  IfcDoorTypeEnum() : m_val(kIfcDoorTypeEnum_unset) {};

  IfcDoorTypeEnum(const IfcDoorTypeEnum &other) : m_val(other.m_val) {};

  IfcDoorTypeEnum(IfcDoorTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcDoorTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcDoorTypeEnum_unset; };

  operator IfcDoorTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcDoorTypeEnum& operator = (const IfcDoorTypeEnum_ val) { if (val < kIfcDoorTypeEnum_unset) m_val = val; else m_val = kIfcDoorTypeEnum_unset; return *this; };

  bool operator == (const IfcDoorTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcDoorTypeEnum &in);

IfcDoorTypeEnum StrToIfcDoorTypeEnum(OdAnsiString val);

enum IfcDoorTypeOperationEnum_

{

  kIfcDoorTypeOperationEnum_SINGLE_SWING_LEFT,

  kIfcDoorTypeOperationEnum_SINGLE_SWING_RIGHT,

  kIfcDoorTypeOperationEnum_DOUBLE_DOOR_SINGLE_SWING,

  kIfcDoorTypeOperationEnum_DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT,

  kIfcDoorTypeOperationEnum_DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT,

  kIfcDoorTypeOperationEnum_DOUBLE_SWING_LEFT,

  kIfcDoorTypeOperationEnum_DOUBLE_SWING_RIGHT,

  kIfcDoorTypeOperationEnum_DOUBLE_DOOR_DOUBLE_SWING,

  kIfcDoorTypeOperationEnum_SLIDING_TO_LEFT,

  kIfcDoorTypeOperationEnum_SLIDING_TO_RIGHT,

  kIfcDoorTypeOperationEnum_DOUBLE_DOOR_SLIDING,

  kIfcDoorTypeOperationEnum_FOLDING_TO_LEFT,

  kIfcDoorTypeOperationEnum_FOLDING_TO_RIGHT,

  kIfcDoorTypeOperationEnum_DOUBLE_DOOR_FOLDING,

  kIfcDoorTypeOperationEnum_REVOLVING,

  kIfcDoorTypeOperationEnum_ROLLINGUP,

  kIfcDoorTypeOperationEnum_SWING_FIXED_LEFT,

  kIfcDoorTypeOperationEnum_SWING_FIXED_RIGHT,

  kIfcDoorTypeOperationEnum_USERDEFINED,

  kIfcDoorTypeOperationEnum_NOTDEFINED,

  kIfcDoorTypeOperationEnum_unset

};


class IfcDoorTypeOperationEnum {

  IfcDoorTypeOperationEnum_ m_val;

public:

  IfcDoorTypeOperationEnum() : m_val(kIfcDoorTypeOperationEnum_unset) {};

  IfcDoorTypeOperationEnum(const IfcDoorTypeOperationEnum &other) : m_val(other.m_val) {};

  IfcDoorTypeOperationEnum(IfcDoorTypeOperationEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcDoorTypeOperationEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcDoorTypeOperationEnum_unset; };

  operator IfcDoorTypeOperationEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcDoorTypeOperationEnum& operator = (const IfcDoorTypeOperationEnum_ val) { if (val < kIfcDoorTypeOperationEnum_unset) m_val = val; else m_val = kIfcDoorTypeOperationEnum_unset; return *this; };

  bool operator == (const IfcDoorTypeOperationEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcDoorTypeOperationEnum &in);

IfcDoorTypeOperationEnum StrToIfcDoorTypeOperationEnum(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_DISHWASHER,

  kIfcElectricApplianceTypeEnum_ELECTRICCOOKER,

  kIfcElectricApplianceTypeEnum_FREESTANDINGELECTRICHEATER,

  kIfcElectricApplianceTypeEnum_FREESTANDINGFAN,

  kIfcElectricApplianceTypeEnum_FREESTANDINGWATERHEATER,

  kIfcElectricApplianceTypeEnum_FREESTANDINGWATERCOOLER,

  kIfcElectricApplianceTypeEnum_FREEZER,

  kIfcElectricApplianceTypeEnum_FRIDGE_FREEZER,

  kIfcElectricApplianceTypeEnum_HANDDRYER,

  kIfcElectricApplianceTypeEnum_KITCHENMACHINE,

  kIfcElectricApplianceTypeEnum_MICROWAVE,

  kIfcElectricApplianceTypeEnum_PHOTOCOPIER,

  kIfcElectricApplianceTypeEnum_REFRIGERATOR,

  kIfcElectricApplianceTypeEnum_TUMBLEDRYER,

  kIfcElectricApplianceTypeEnum_VENDINGMACHINE,

  kIfcElectricApplianceTypeEnum_WASHINGMACHINE,

  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 IfcElectricDistributionBoardTypeEnum_

{

  kIfcElectricDistributionBoardTypeEnum_CONSUMERUNIT,

  kIfcElectricDistributionBoardTypeEnum_DISTRIBUTIONBOARD,

  kIfcElectricDistributionBoardTypeEnum_MOTORCONTROLCENTRE,

  kIfcElectricDistributionBoardTypeEnum_SWITCHBOARD,

  kIfcElectricDistributionBoardTypeEnum_USERDEFINED,

  kIfcElectricDistributionBoardTypeEnum_NOTDEFINED,

  kIfcElectricDistributionBoardTypeEnum_unset

};


class IfcElectricDistributionBoardTypeEnum {

  IfcElectricDistributionBoardTypeEnum_ m_val;

public:

  IfcElectricDistributionBoardTypeEnum() : m_val(kIfcElectricDistributionBoardTypeEnum_unset) {};

  IfcElectricDistributionBoardTypeEnum(const IfcElectricDistributionBoardTypeEnum &other) : m_val(other.m_val) {};

  IfcElectricDistributionBoardTypeEnum(IfcElectricDistributionBoardTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcElectricDistributionBoardTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcElectricDistributionBoardTypeEnum_unset; };

  operator IfcElectricDistributionBoardTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcElectricDistributionBoardTypeEnum& operator = (const IfcElectricDistributionBoardTypeEnum_ val) { if (val < kIfcElectricDistributionBoardTypeEnum_unset) m_val = val; else m_val = kIfcElectricDistributionBoardTypeEnum_unset; return *this; };

  bool operator == (const IfcElectricDistributionBoardTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcElectricDistributionBoardTypeEnum &in);

IfcElectricDistributionBoardTypeEnum StrToIfcElectricDistributionBoardTypeEnum(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_CHP,

  kIfcElectricGeneratorTypeEnum_ENGINEGENERATOR,

  kIfcElectricGeneratorTypeEnum_STANDALONE,

  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 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 IfcEngineTypeEnum_

{

  kIfcEngineTypeEnum_EXTERNALCOMBUSTION,

  kIfcEngineTypeEnum_INTERNALCOMBUSTION,

  kIfcEngineTypeEnum_USERDEFINED,

  kIfcEngineTypeEnum_NOTDEFINED,

  kIfcEngineTypeEnum_unset

};


class IfcEngineTypeEnum {

  IfcEngineTypeEnum_ m_val;

public:

  IfcEngineTypeEnum() : m_val(kIfcEngineTypeEnum_unset) {};

  IfcEngineTypeEnum(const IfcEngineTypeEnum &other) : m_val(other.m_val) {};

  IfcEngineTypeEnum(IfcEngineTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcEngineTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcEngineTypeEnum_unset; };

  operator IfcEngineTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcEngineTypeEnum& operator = (const IfcEngineTypeEnum_ val) { if (val < kIfcEngineTypeEnum_unset) m_val = val; else m_val = kIfcEngineTypeEnum_unset; return *this; };

  bool operator == (const IfcEngineTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcEngineTypeEnum &in);

IfcEngineTypeEnum StrToIfcEngineTypeEnum(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_DIRECTEXPANSION,

  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 IfcEventTriggerTypeEnum_

{

  kIfcEventTriggerTypeEnum_EVENTRULE,

  kIfcEventTriggerTypeEnum_EVENTMESSAGE,

  kIfcEventTriggerTypeEnum_EVENTTIME,

  kIfcEventTriggerTypeEnum_EVENTCOMPLEX,

  kIfcEventTriggerTypeEnum_USERDEFINED,

  kIfcEventTriggerTypeEnum_NOTDEFINED,

  kIfcEventTriggerTypeEnum_unset

};


class IfcEventTriggerTypeEnum {

  IfcEventTriggerTypeEnum_ m_val;

public:

  IfcEventTriggerTypeEnum() : m_val(kIfcEventTriggerTypeEnum_unset) {};

  IfcEventTriggerTypeEnum(const IfcEventTriggerTypeEnum &other) : m_val(other.m_val) {};

  IfcEventTriggerTypeEnum(IfcEventTriggerTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcEventTriggerTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcEventTriggerTypeEnum_unset; };

  operator IfcEventTriggerTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcEventTriggerTypeEnum& operator = (const IfcEventTriggerTypeEnum_ val) { if (val < kIfcEventTriggerTypeEnum_unset) m_val = val; else m_val = kIfcEventTriggerTypeEnum_unset; return *this; };

  bool operator == (const IfcEventTriggerTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcEventTriggerTypeEnum &in);

IfcEventTriggerTypeEnum StrToIfcEventTriggerTypeEnum(OdAnsiString val);

enum IfcEventTypeEnum_

{

  kIfcEventTypeEnum_STARTEVENT,

  kIfcEventTypeEnum_ENDEVENT,

  kIfcEventTypeEnum_INTERMEDIATEEVENT,

  kIfcEventTypeEnum_USERDEFINED,

  kIfcEventTypeEnum_NOTDEFINED,

  kIfcEventTypeEnum_unset

};


class IfcEventTypeEnum {

  IfcEventTypeEnum_ m_val;

public:

  IfcEventTypeEnum() : m_val(kIfcEventTypeEnum_unset) {};

  IfcEventTypeEnum(const IfcEventTypeEnum &other) : m_val(other.m_val) {};

  IfcEventTypeEnum(IfcEventTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcEventTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcEventTypeEnum_unset; };

  operator IfcEventTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcEventTypeEnum& operator = (const IfcEventTypeEnum_ val) { if (val < kIfcEventTypeEnum_unset) m_val = val; else m_val = kIfcEventTypeEnum_unset; return *this; };

  bool operator == (const IfcEventTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcEventTypeEnum &in);

IfcEventTypeEnum StrToIfcEventTypeEnum(OdAnsiString val);

enum IfcExternalSpatialElementTypeEnum_

{

  kIfcExternalSpatialElementTypeEnum_EXTERNAL,

  kIfcExternalSpatialElementTypeEnum_EXTERNAL_EARTH,

  kIfcExternalSpatialElementTypeEnum_EXTERNAL_WATER,

  kIfcExternalSpatialElementTypeEnum_EXTERNAL_FIRE,

  kIfcExternalSpatialElementTypeEnum_USERDEFINED,

  kIfcExternalSpatialElementTypeEnum_NOTDEFINED,

  kIfcExternalSpatialElementTypeEnum_unset

};


class IfcExternalSpatialElementTypeEnum {

  IfcExternalSpatialElementTypeEnum_ m_val;

public:

  IfcExternalSpatialElementTypeEnum() : m_val(kIfcExternalSpatialElementTypeEnum_unset) {};

  IfcExternalSpatialElementTypeEnum(const IfcExternalSpatialElementTypeEnum &other) : m_val(other.m_val) {};

  IfcExternalSpatialElementTypeEnum(IfcExternalSpatialElementTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcExternalSpatialElementTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcExternalSpatialElementTypeEnum_unset; };

  operator IfcExternalSpatialElementTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcExternalSpatialElementTypeEnum& operator = (const IfcExternalSpatialElementTypeEnum_ val) { if (val < kIfcExternalSpatialElementTypeEnum_unset) m_val = val; else m_val = kIfcExternalSpatialElementTypeEnum_unset; return *this; };

  bool operator == (const IfcExternalSpatialElementTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcExternalSpatialElementTypeEnum &in);

IfcExternalSpatialElementTypeEnum StrToIfcExternalSpatialElementTypeEnum(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 IfcFastenerTypeEnum_

{

  kIfcFastenerTypeEnum_GLUE,

  kIfcFastenerTypeEnum_MORTAR,

  kIfcFastenerTypeEnum_WELD,

  kIfcFastenerTypeEnum_USERDEFINED,

  kIfcFastenerTypeEnum_NOTDEFINED,

  kIfcFastenerTypeEnum_unset

};


class IfcFastenerTypeEnum {

  IfcFastenerTypeEnum_ m_val;

public:

  IfcFastenerTypeEnum() : m_val(kIfcFastenerTypeEnum_unset) {};

  IfcFastenerTypeEnum(const IfcFastenerTypeEnum &other) : m_val(other.m_val) {};

  IfcFastenerTypeEnum(IfcFastenerTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcFastenerTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcFastenerTypeEnum_unset; };

  operator IfcFastenerTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcFastenerTypeEnum& operator = (const IfcFastenerTypeEnum_ val) { if (val < kIfcFastenerTypeEnum_unset) m_val = val; else m_val = kIfcFastenerTypeEnum_unset; return *this; };

  bool operator == (const IfcFastenerTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcFastenerTypeEnum &in);

IfcFastenerTypeEnum StrToIfcFastenerTypeEnum(OdAnsiString val);

enum IfcFilterTypeEnum_

{

  kIfcFilterTypeEnum_AIRPARTICLEFILTER,

  kIfcFilterTypeEnum_COMPRESSEDAIRFILTER,

  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_ENERGYMETER,

  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_CAISSON_FOUNDATION,

  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 IfcFurnitureTypeEnum_

{

  kIfcFurnitureTypeEnum_CHAIR,

  kIfcFurnitureTypeEnum_TABLE,

  kIfcFurnitureTypeEnum_DESK,

  kIfcFurnitureTypeEnum_BED,

  kIfcFurnitureTypeEnum_FILECABINET,

  kIfcFurnitureTypeEnum_SHELF,

  kIfcFurnitureTypeEnum_SOFA,

  kIfcFurnitureTypeEnum_USERDEFINED,

  kIfcFurnitureTypeEnum_NOTDEFINED,

  kIfcFurnitureTypeEnum_unset

};


class IfcFurnitureTypeEnum {

  IfcFurnitureTypeEnum_ m_val;

public:

  IfcFurnitureTypeEnum() : m_val(kIfcFurnitureTypeEnum_unset) {};

  IfcFurnitureTypeEnum(const IfcFurnitureTypeEnum &other) : m_val(other.m_val) {};

  IfcFurnitureTypeEnum(IfcFurnitureTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcFurnitureTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcFurnitureTypeEnum_unset; };

  operator IfcFurnitureTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcFurnitureTypeEnum& operator = (const IfcFurnitureTypeEnum_ val) { if (val < kIfcFurnitureTypeEnum_unset) m_val = val; else m_val = kIfcFurnitureTypeEnum_unset; return *this; };

  bool operator == (const IfcFurnitureTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcFurnitureTypeEnum &in);

IfcFurnitureTypeEnum StrToIfcFurnitureTypeEnum(OdAnsiString val);

enum IfcGeographicElementTypeEnum_

{

  kIfcGeographicElementTypeEnum_TERRAIN,

  kIfcGeographicElementTypeEnum_USERDEFINED,

  kIfcGeographicElementTypeEnum_NOTDEFINED,

  kIfcGeographicElementTypeEnum_unset

};


class IfcGeographicElementTypeEnum {

  IfcGeographicElementTypeEnum_ m_val;

public:

  IfcGeographicElementTypeEnum() : m_val(kIfcGeographicElementTypeEnum_unset) {};

  IfcGeographicElementTypeEnum(const IfcGeographicElementTypeEnum &other) : m_val(other.m_val) {};

  IfcGeographicElementTypeEnum(IfcGeographicElementTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcGeographicElementTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcGeographicElementTypeEnum_unset; };

  operator IfcGeographicElementTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcGeographicElementTypeEnum& operator = (const IfcGeographicElementTypeEnum_ val) { if (val < kIfcGeographicElementTypeEnum_unset) m_val = val; else m_val = kIfcGeographicElementTypeEnum_unset; return *this; };

  bool operator == (const IfcGeographicElementTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcGeographicElementTypeEnum &in);

IfcGeographicElementTypeEnum StrToIfcGeographicElementTypeEnum(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 IfcGridTypeEnum_

{

  kIfcGridTypeEnum_RECTANGULAR,

  kIfcGridTypeEnum_RADIAL,

  kIfcGridTypeEnum_TRIANGULAR,

  kIfcGridTypeEnum_IRREGULAR,

  kIfcGridTypeEnum_USERDEFINED,

  kIfcGridTypeEnum_NOTDEFINED,

  kIfcGridTypeEnum_unset

};


class IfcGridTypeEnum {

  IfcGridTypeEnum_ m_val;

public:

  IfcGridTypeEnum() : m_val(kIfcGridTypeEnum_unset) {};

  IfcGridTypeEnum(const IfcGridTypeEnum &other) : m_val(other.m_val) {};

  IfcGridTypeEnum(IfcGridTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcGridTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcGridTypeEnum_unset; };

  operator IfcGridTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcGridTypeEnum& operator = (const IfcGridTypeEnum_ val) { if (val < kIfcGridTypeEnum_unset) m_val = val; else m_val = kIfcGridTypeEnum_unset; return *this; };

  bool operator == (const IfcGridTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcGridTypeEnum &in);

IfcGridTypeEnum StrToIfcGridTypeEnum(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 IfcInterceptorTypeEnum_

{

  kIfcInterceptorTypeEnum_CYCLONIC,

  kIfcInterceptorTypeEnum_GREASE,

  kIfcInterceptorTypeEnum_OIL,

  kIfcInterceptorTypeEnum_PETROL,

  kIfcInterceptorTypeEnum_USERDEFINED,

  kIfcInterceptorTypeEnum_NOTDEFINED,

  kIfcInterceptorTypeEnum_unset

};


class IfcInterceptorTypeEnum {

  IfcInterceptorTypeEnum_ m_val;

public:

  IfcInterceptorTypeEnum() : m_val(kIfcInterceptorTypeEnum_unset) {};

  IfcInterceptorTypeEnum(const IfcInterceptorTypeEnum &other) : m_val(other.m_val) {};

  IfcInterceptorTypeEnum(IfcInterceptorTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcInterceptorTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcInterceptorTypeEnum_unset; };

  operator IfcInterceptorTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcInterceptorTypeEnum& operator = (const IfcInterceptorTypeEnum_ val) { if (val < kIfcInterceptorTypeEnum_unset) m_val = val; else m_val = kIfcInterceptorTypeEnum_unset; return *this; };

  bool operator == (const IfcInterceptorTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcInterceptorTypeEnum &in);

IfcInterceptorTypeEnum StrToIfcInterceptorTypeEnum(OdAnsiString val);

enum IfcInternalOrExternalEnum_

{

  kIfcInternalOrExternalEnum_INTERNAL,

  kIfcInternalOrExternalEnum_EXTERNAL,

  kIfcInternalOrExternalEnum_EXTERNAL_EARTH,

  kIfcInternalOrExternalEnum_EXTERNAL_WATER,

  kIfcInternalOrExternalEnum_EXTERNAL_FIRE,

  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_DATA,

  kIfcJunctionBoxTypeEnum_POWER,

  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 IfcKnotType_

{

  kIfcKnotType_UNIFORM_KNOTS,

  kIfcKnotType_QUASI_UNIFORM_KNOTS,

  kIfcKnotType_PIECEWISE_BEZIER_KNOTS,

  kIfcKnotType_UNSPECIFIED,

  kIfcKnotType_unset

};


class IfcKnotType {

  IfcKnotType_ m_val;

public:

  IfcKnotType() : m_val(kIfcKnotType_unset) {};

  IfcKnotType(const IfcKnotType &other) : m_val(other.m_val) {};

  IfcKnotType(IfcKnotType_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcKnotType_unset ? 1 : 0; };

  void nullify() { m_val = kIfcKnotType_unset; };

  operator IfcKnotType_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcKnotType& operator = (const IfcKnotType_ val) { if (val < kIfcKnotType_unset) m_val = val; else m_val = kIfcKnotType_unset; return *this; };

  bool operator == (const IfcKnotType &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcKnotType &in);

IfcKnotType StrToIfcKnotType(OdAnsiString val);

enum IfcLaborResourceTypeEnum_

{

  kIfcLaborResourceTypeEnum_ADMINISTRATION,

  kIfcLaborResourceTypeEnum_CARPENTRY,

  kIfcLaborResourceTypeEnum_CLEANING,

  kIfcLaborResourceTypeEnum_CONCRETE,

  kIfcLaborResourceTypeEnum_DRYWALL,

  kIfcLaborResourceTypeEnum_ELECTRIC,

  kIfcLaborResourceTypeEnum_FINISHING,

  kIfcLaborResourceTypeEnum_FLOORING,

  kIfcLaborResourceTypeEnum_GENERAL,

  kIfcLaborResourceTypeEnum_HVAC,

  kIfcLaborResourceTypeEnum_LANDSCAPING,

  kIfcLaborResourceTypeEnum_MASONRY,

  kIfcLaborResourceTypeEnum_PAINTING,

  kIfcLaborResourceTypeEnum_PAVING,

  kIfcLaborResourceTypeEnum_PLUMBING,

  kIfcLaborResourceTypeEnum_ROOFING,

  kIfcLaborResourceTypeEnum_SITEGRADING,

  kIfcLaborResourceTypeEnum_STEELWORK,

  kIfcLaborResourceTypeEnum_SURVEYING,

  kIfcLaborResourceTypeEnum_USERDEFINED,

  kIfcLaborResourceTypeEnum_NOTDEFINED,

  kIfcLaborResourceTypeEnum_unset

};


class IfcLaborResourceTypeEnum {

  IfcLaborResourceTypeEnum_ m_val;

public:

  IfcLaborResourceTypeEnum() : m_val(kIfcLaborResourceTypeEnum_unset) {};

  IfcLaborResourceTypeEnum(const IfcLaborResourceTypeEnum &other) : m_val(other.m_val) {};

  IfcLaborResourceTypeEnum(IfcLaborResourceTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcLaborResourceTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcLaborResourceTypeEnum_unset; };

  operator IfcLaborResourceTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcLaborResourceTypeEnum& operator = (const IfcLaborResourceTypeEnum_ val) { if (val < kIfcLaborResourceTypeEnum_unset) m_val = val; else m_val = kIfcLaborResourceTypeEnum_unset; return *this; };

  bool operator == (const IfcLaborResourceTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcLaborResourceTypeEnum &in);

IfcLaborResourceTypeEnum StrToIfcLaborResourceTypeEnum(OdAnsiString val);

enum IfcLampTypeEnum_

{

  kIfcLampTypeEnum_COMPACTFLUORESCENT,

  kIfcLampTypeEnum_FLUORESCENT,

  kIfcLampTypeEnum_HALOGEN,

  kIfcLampTypeEnum_HIGHPRESSUREMERCURY,

  kIfcLampTypeEnum_HIGHPRESSURESODIUM,

  kIfcLampTypeEnum_LED,

  kIfcLampTypeEnum_METALHALIDE,

  kIfcLampTypeEnum_OLED,

  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_SECURITYLIGHTING,

  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,

  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_LOGICALXOR,

  kIfcLogicalOperatorEnum_LOGICALNOTAND,

  kIfcLogicalOperatorEnum_LOGICALNOTOR,

  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 IfcMechanicalFastenerTypeEnum_

{

  kIfcMechanicalFastenerTypeEnum_ANCHORBOLT,

  kIfcMechanicalFastenerTypeEnum_BOLT,

  kIfcMechanicalFastenerTypeEnum_DOWEL,

  kIfcMechanicalFastenerTypeEnum_NAIL,

  kIfcMechanicalFastenerTypeEnum_NAILPLATE,

  kIfcMechanicalFastenerTypeEnum_RIVET,

  kIfcMechanicalFastenerTypeEnum_SCREW,

  kIfcMechanicalFastenerTypeEnum_SHEARCONNECTOR,

  kIfcMechanicalFastenerTypeEnum_STAPLE,

  kIfcMechanicalFastenerTypeEnum_STUDSHEARCONNECTOR,

  kIfcMechanicalFastenerTypeEnum_USERDEFINED,

  kIfcMechanicalFastenerTypeEnum_NOTDEFINED,

  kIfcMechanicalFastenerTypeEnum_unset

};


class IfcMechanicalFastenerTypeEnum {

  IfcMechanicalFastenerTypeEnum_ m_val;

public:

  IfcMechanicalFastenerTypeEnum() : m_val(kIfcMechanicalFastenerTypeEnum_unset) {};

  IfcMechanicalFastenerTypeEnum(const IfcMechanicalFastenerTypeEnum &other) : m_val(other.m_val) {};

  IfcMechanicalFastenerTypeEnum(IfcMechanicalFastenerTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcMechanicalFastenerTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcMechanicalFastenerTypeEnum_unset; };

  operator IfcMechanicalFastenerTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcMechanicalFastenerTypeEnum& operator = (const IfcMechanicalFastenerTypeEnum_ val) { if (val < kIfcMechanicalFastenerTypeEnum_unset) m_val = val; else m_val = kIfcMechanicalFastenerTypeEnum_unset; return *this; };

  bool operator == (const IfcMechanicalFastenerTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcMechanicalFastenerTypeEnum &in);

IfcMechanicalFastenerTypeEnum StrToIfcMechanicalFastenerTypeEnum(OdAnsiString val);

enum IfcMedicalDeviceTypeEnum_

{

  kIfcMedicalDeviceTypeEnum_AIRSTATION,

  kIfcMedicalDeviceTypeEnum_FEEDAIRUNIT,

  kIfcMedicalDeviceTypeEnum_OXYGENGENERATOR,

  kIfcMedicalDeviceTypeEnum_OXYGENPLANT,

  kIfcMedicalDeviceTypeEnum_VACUUMSTATION,

  kIfcMedicalDeviceTypeEnum_USERDEFINED,

  kIfcMedicalDeviceTypeEnum_NOTDEFINED,

  kIfcMedicalDeviceTypeEnum_unset

};


class IfcMedicalDeviceTypeEnum {

  IfcMedicalDeviceTypeEnum_ m_val;

public:

  IfcMedicalDeviceTypeEnum() : m_val(kIfcMedicalDeviceTypeEnum_unset) {};

  IfcMedicalDeviceTypeEnum(const IfcMedicalDeviceTypeEnum &other) : m_val(other.m_val) {};

  IfcMedicalDeviceTypeEnum(IfcMedicalDeviceTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcMedicalDeviceTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcMedicalDeviceTypeEnum_unset; };

  operator IfcMedicalDeviceTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcMedicalDeviceTypeEnum& operator = (const IfcMedicalDeviceTypeEnum_ val) { if (val < kIfcMedicalDeviceTypeEnum_unset) m_val = val; else m_val = kIfcMedicalDeviceTypeEnum_unset; return *this; };

  bool operator == (const IfcMedicalDeviceTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcMedicalDeviceTypeEnum &in);

IfcMedicalDeviceTypeEnum StrToIfcMedicalDeviceTypeEnum(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_CODEWAIVER,

  kIfcObjectiveEnum_DESIGNINTENT,

  kIfcObjectiveEnum_EXTERNAL,

  kIfcObjectiveEnum_HEALTHANDSAFETY,

  kIfcObjectiveEnum_MERGECONFLICT,

  kIfcObjectiveEnum_MODELVIEW,

  kIfcObjectiveEnum_PARAMETER,

  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 IfcOpeningElementTypeEnum_

{

  kIfcOpeningElementTypeEnum_OPENING,

  kIfcOpeningElementTypeEnum_RECESS,

  kIfcOpeningElementTypeEnum_USERDEFINED,

  kIfcOpeningElementTypeEnum_NOTDEFINED,

  kIfcOpeningElementTypeEnum_unset

};


class IfcOpeningElementTypeEnum {

  IfcOpeningElementTypeEnum_ m_val;

public:

  IfcOpeningElementTypeEnum() : m_val(kIfcOpeningElementTypeEnum_unset) {};

  IfcOpeningElementTypeEnum(const IfcOpeningElementTypeEnum &other) : m_val(other.m_val) {};

  IfcOpeningElementTypeEnum(IfcOpeningElementTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcOpeningElementTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcOpeningElementTypeEnum_unset; };

  operator IfcOpeningElementTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcOpeningElementTypeEnum& operator = (const IfcOpeningElementTypeEnum_ val) { if (val < kIfcOpeningElementTypeEnum_unset) m_val = val; else m_val = kIfcOpeningElementTypeEnum_unset; return *this; };

  bool operator == (const IfcOpeningElementTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcOpeningElementTypeEnum &in);

IfcOpeningElementTypeEnum StrToIfcOpeningElementTypeEnum(OdAnsiString val);

enum IfcOutletTypeEnum_

{

  kIfcOutletTypeEnum_AUDIOVISUALOUTLET,

  kIfcOutletTypeEnum_COMMUNICATIONSOUTLET,

  kIfcOutletTypeEnum_POWEROUTLET,

  kIfcOutletTypeEnum_DATAOUTLET,

  kIfcOutletTypeEnum_TELEPHONEOUTLET,

  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 IfcPerformanceHistoryTypeEnum_

{

  kIfcPerformanceHistoryTypeEnum_USERDEFINED,

  kIfcPerformanceHistoryTypeEnum_NOTDEFINED,

  kIfcPerformanceHistoryTypeEnum_unset

};


class IfcPerformanceHistoryTypeEnum {

  IfcPerformanceHistoryTypeEnum_ m_val;

public:

  IfcPerformanceHistoryTypeEnum() : m_val(kIfcPerformanceHistoryTypeEnum_unset) {};

  IfcPerformanceHistoryTypeEnum(const IfcPerformanceHistoryTypeEnum &other) : m_val(other.m_val) {};

  IfcPerformanceHistoryTypeEnum(IfcPerformanceHistoryTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcPerformanceHistoryTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcPerformanceHistoryTypeEnum_unset; };

  operator IfcPerformanceHistoryTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcPerformanceHistoryTypeEnum& operator = (const IfcPerformanceHistoryTypeEnum_ val) { if (val < kIfcPerformanceHistoryTypeEnum_unset) m_val = val; else m_val = kIfcPerformanceHistoryTypeEnum_unset; return *this; };

  bool operator == (const IfcPerformanceHistoryTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcPerformanceHistoryTypeEnum &in);

IfcPerformanceHistoryTypeEnum StrToIfcPerformanceHistoryTypeEnum(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 IfcPermitTypeEnum_

{

  kIfcPermitTypeEnum_ACCESS,

  kIfcPermitTypeEnum_BUILDING,

  kIfcPermitTypeEnum_WORK,

  kIfcPermitTypeEnum_USERDEFINED,

  kIfcPermitTypeEnum_NOTDEFINED,

  kIfcPermitTypeEnum_unset

};


class IfcPermitTypeEnum {

  IfcPermitTypeEnum_ m_val;

public:

  IfcPermitTypeEnum() : m_val(kIfcPermitTypeEnum_unset) {};

  IfcPermitTypeEnum(const IfcPermitTypeEnum &other) : m_val(other.m_val) {};

  IfcPermitTypeEnum(IfcPermitTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcPermitTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcPermitTypeEnum_unset; };

  operator IfcPermitTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcPermitTypeEnum& operator = (const IfcPermitTypeEnum_ val) { if (val < kIfcPermitTypeEnum_unset) m_val = val; else m_val = kIfcPermitTypeEnum_unset; return *this; };

  bool operator == (const IfcPermitTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcPermitTypeEnum &in);

IfcPermitTypeEnum StrToIfcPermitTypeEnum(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_BORED,

  kIfcPileTypeEnum_DRIVEN,

  kIfcPileTypeEnum_JETGROUTING,

  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_CULVERT,

  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 IfcPreferredSurfaceCurveRepresentation_

{

  kIfcPreferredSurfaceCurveRepresentation_CURVE3D,

  kIfcPreferredSurfaceCurveRepresentation_PCURVE_S1,

  kIfcPreferredSurfaceCurveRepresentation_PCURVE_S2,

  kIfcPreferredSurfaceCurveRepresentation_unset

};


class IfcPreferredSurfaceCurveRepresentation {

  IfcPreferredSurfaceCurveRepresentation_ m_val;

public:

  IfcPreferredSurfaceCurveRepresentation() : m_val(kIfcPreferredSurfaceCurveRepresentation_unset) {};

  IfcPreferredSurfaceCurveRepresentation(const IfcPreferredSurfaceCurveRepresentation &other) : m_val(other.m_val) {};

  IfcPreferredSurfaceCurveRepresentation(IfcPreferredSurfaceCurveRepresentation_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcPreferredSurfaceCurveRepresentation_unset ? 1 : 0; };

  void nullify() { m_val = kIfcPreferredSurfaceCurveRepresentation_unset; };

  operator IfcPreferredSurfaceCurveRepresentation_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcPreferredSurfaceCurveRepresentation& operator = (const IfcPreferredSurfaceCurveRepresentation_ val) { if (val < kIfcPreferredSurfaceCurveRepresentation_unset) m_val = val; else m_val = kIfcPreferredSurfaceCurveRepresentation_unset; return *this; };

  bool operator == (const IfcPreferredSurfaceCurveRepresentation &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcPreferredSurfaceCurveRepresentation &in);

IfcPreferredSurfaceCurveRepresentation StrToIfcPreferredSurfaceCurveRepresentation(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 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 IfcProjectionElementTypeEnum_

{

  kIfcProjectionElementTypeEnum_USERDEFINED,

  kIfcProjectionElementTypeEnum_NOTDEFINED,

  kIfcProjectionElementTypeEnum_unset

};


class IfcProjectionElementTypeEnum {

  IfcProjectionElementTypeEnum_ m_val;

public:

  IfcProjectionElementTypeEnum() : m_val(kIfcProjectionElementTypeEnum_unset) {};

  IfcProjectionElementTypeEnum(const IfcProjectionElementTypeEnum &other) : m_val(other.m_val) {};

  IfcProjectionElementTypeEnum(IfcProjectionElementTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcProjectionElementTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcProjectionElementTypeEnum_unset; };

  operator IfcProjectionElementTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcProjectionElementTypeEnum& operator = (const IfcProjectionElementTypeEnum_ val) { if (val < kIfcProjectionElementTypeEnum_unset) m_val = val; else m_val = kIfcProjectionElementTypeEnum_unset; return *this; };

  bool operator == (const IfcProjectionElementTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcProjectionElementTypeEnum &in);

IfcProjectionElementTypeEnum StrToIfcProjectionElementTypeEnum(OdAnsiString val);

enum IfcPropertySetTemplateTypeEnum_

{

  kIfcPropertySetTemplateTypeEnum_PSET_TYPEDRIVENONLY,

  kIfcPropertySetTemplateTypeEnum_PSET_TYPEDRIVENOVERRIDE,

  kIfcPropertySetTemplateTypeEnum_PSET_OCCURRENCEDRIVEN,

  kIfcPropertySetTemplateTypeEnum_PSET_PERFORMANCEDRIVEN,

  kIfcPropertySetTemplateTypeEnum_QTO_TYPEDRIVENONLY,

  kIfcPropertySetTemplateTypeEnum_QTO_TYPEDRIVENOVERRIDE,

  kIfcPropertySetTemplateTypeEnum_QTO_OCCURRENCEDRIVEN,

  kIfcPropertySetTemplateTypeEnum_NOTDEFINED,

  kIfcPropertySetTemplateTypeEnum_unset

};


class IfcPropertySetTemplateTypeEnum {

  IfcPropertySetTemplateTypeEnum_ m_val;

public:

  IfcPropertySetTemplateTypeEnum() : m_val(kIfcPropertySetTemplateTypeEnum_unset) {};

  IfcPropertySetTemplateTypeEnum(const IfcPropertySetTemplateTypeEnum &other) : m_val(other.m_val) {};

  IfcPropertySetTemplateTypeEnum(IfcPropertySetTemplateTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcPropertySetTemplateTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcPropertySetTemplateTypeEnum_unset; };

  operator IfcPropertySetTemplateTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcPropertySetTemplateTypeEnum& operator = (const IfcPropertySetTemplateTypeEnum_ val) { if (val < kIfcPropertySetTemplateTypeEnum_unset) m_val = val; else m_val = kIfcPropertySetTemplateTypeEnum_unset; return *this; };

  bool operator == (const IfcPropertySetTemplateTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcPropertySetTemplateTypeEnum &in);

IfcPropertySetTemplateTypeEnum StrToIfcPropertySetTemplateTypeEnum(OdAnsiString val);

enum IfcProtectiveDeviceTrippingUnitTypeEnum_

{

  kIfcProtectiveDeviceTrippingUnitTypeEnum_ELECTRONIC,

  kIfcProtectiveDeviceTrippingUnitTypeEnum_ELECTROMAGNETIC,

  kIfcProtectiveDeviceTrippingUnitTypeEnum_RESIDUALCURRENT,

  kIfcProtectiveDeviceTrippingUnitTypeEnum_THERMAL,

  kIfcProtectiveDeviceTrippingUnitTypeEnum_USERDEFINED,

  kIfcProtectiveDeviceTrippingUnitTypeEnum_NOTDEFINED,

  kIfcProtectiveDeviceTrippingUnitTypeEnum_unset

};


class IfcProtectiveDeviceTrippingUnitTypeEnum {

  IfcProtectiveDeviceTrippingUnitTypeEnum_ m_val;

public:

  IfcProtectiveDeviceTrippingUnitTypeEnum() : m_val(kIfcProtectiveDeviceTrippingUnitTypeEnum_unset) {};

  IfcProtectiveDeviceTrippingUnitTypeEnum(const IfcProtectiveDeviceTrippingUnitTypeEnum &other) : m_val(other.m_val) {};

  IfcProtectiveDeviceTrippingUnitTypeEnum(IfcProtectiveDeviceTrippingUnitTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcProtectiveDeviceTrippingUnitTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcProtectiveDeviceTrippingUnitTypeEnum_unset; };

  operator IfcProtectiveDeviceTrippingUnitTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcProtectiveDeviceTrippingUnitTypeEnum& operator = (const IfcProtectiveDeviceTrippingUnitTypeEnum_ val) { if (val < kIfcProtectiveDeviceTrippingUnitTypeEnum_unset) m_val = val; else m_val = kIfcProtectiveDeviceTrippingUnitTypeEnum_unset; return *this; };

  bool operator == (const IfcProtectiveDeviceTrippingUnitTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcProtectiveDeviceTrippingUnitTypeEnum &in);

IfcProtectiveDeviceTrippingUnitTypeEnum StrToIfcProtectiveDeviceTrippingUnitTypeEnum(OdAnsiString val);

enum IfcProtectiveDeviceTypeEnum_

{

  kIfcProtectiveDeviceTypeEnum_CIRCUITBREAKER,

  kIfcProtectiveDeviceTypeEnum_EARTHLEAKAGECIRCUITBREAKER,

  kIfcProtectiveDeviceTypeEnum_EARTHINGSWITCH,

  kIfcProtectiveDeviceTypeEnum_FUSEDISCONNECTOR,

  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_SUBMERSIBLEPUMP,

  kIfcPumpTypeEnum_SUMPPUMP,

  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 IfcRecurrenceTypeEnum_

{

  kIfcRecurrenceTypeEnum_DAILY,

  kIfcRecurrenceTypeEnum_WEEKLY,

  kIfcRecurrenceTypeEnum_MONTHLY_BY_DAY_OF_MONTH,

  kIfcRecurrenceTypeEnum_MONTHLY_BY_POSITION,

  kIfcRecurrenceTypeEnum_BY_DAY_COUNT,

  kIfcRecurrenceTypeEnum_BY_WEEKDAY_COUNT,

  kIfcRecurrenceTypeEnum_YEARLY_BY_DAY_OF_MONTH,

  kIfcRecurrenceTypeEnum_YEARLY_BY_POSITION,

  kIfcRecurrenceTypeEnum_unset

};


class IfcRecurrenceTypeEnum {

  IfcRecurrenceTypeEnum_ m_val;

public:

  IfcRecurrenceTypeEnum() : m_val(kIfcRecurrenceTypeEnum_unset) {};

  IfcRecurrenceTypeEnum(const IfcRecurrenceTypeEnum &other) : m_val(other.m_val) {};

  IfcRecurrenceTypeEnum(IfcRecurrenceTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcRecurrenceTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcRecurrenceTypeEnum_unset; };

  operator IfcRecurrenceTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcRecurrenceTypeEnum& operator = (const IfcRecurrenceTypeEnum_ val) { if (val < kIfcRecurrenceTypeEnum_unset) m_val = val; else m_val = kIfcRecurrenceTypeEnum_unset; return *this; };

  bool operator == (const IfcRecurrenceTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcRecurrenceTypeEnum &in);

IfcRecurrenceTypeEnum StrToIfcRecurrenceTypeEnum(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_ANCHORING,

  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 IfcReinforcingBarTypeEnum_

{

  kIfcReinforcingBarTypeEnum_ANCHORING,

  kIfcReinforcingBarTypeEnum_EDGE,

  kIfcReinforcingBarTypeEnum_LIGATURE,

  kIfcReinforcingBarTypeEnum_MAIN,

  kIfcReinforcingBarTypeEnum_PUNCHING,

  kIfcReinforcingBarTypeEnum_RING,

  kIfcReinforcingBarTypeEnum_SHEAR,

  kIfcReinforcingBarTypeEnum_STUD,

  kIfcReinforcingBarTypeEnum_USERDEFINED,

  kIfcReinforcingBarTypeEnum_NOTDEFINED,

  kIfcReinforcingBarTypeEnum_unset

};


class IfcReinforcingBarTypeEnum {

  IfcReinforcingBarTypeEnum_ m_val;

public:

  IfcReinforcingBarTypeEnum() : m_val(kIfcReinforcingBarTypeEnum_unset) {};

  IfcReinforcingBarTypeEnum(const IfcReinforcingBarTypeEnum &other) : m_val(other.m_val) {};

  IfcReinforcingBarTypeEnum(IfcReinforcingBarTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcReinforcingBarTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcReinforcingBarTypeEnum_unset; };

  operator IfcReinforcingBarTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcReinforcingBarTypeEnum& operator = (const IfcReinforcingBarTypeEnum_ val) { if (val < kIfcReinforcingBarTypeEnum_unset) m_val = val; else m_val = kIfcReinforcingBarTypeEnum_unset; return *this; };

  bool operator == (const IfcReinforcingBarTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcReinforcingBarTypeEnum &in);

IfcReinforcingBarTypeEnum StrToIfcReinforcingBarTypeEnum(OdAnsiString val);

enum IfcReinforcingMeshTypeEnum_

{

  kIfcReinforcingMeshTypeEnum_USERDEFINED,

  kIfcReinforcingMeshTypeEnum_NOTDEFINED,

  kIfcReinforcingMeshTypeEnum_unset

};


class IfcReinforcingMeshTypeEnum {

  IfcReinforcingMeshTypeEnum_ m_val;

public:

  IfcReinforcingMeshTypeEnum() : m_val(kIfcReinforcingMeshTypeEnum_unset) {};

  IfcReinforcingMeshTypeEnum(const IfcReinforcingMeshTypeEnum &other) : m_val(other.m_val) {};

  IfcReinforcingMeshTypeEnum(IfcReinforcingMeshTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcReinforcingMeshTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcReinforcingMeshTypeEnum_unset; };

  operator IfcReinforcingMeshTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcReinforcingMeshTypeEnum& operator = (const IfcReinforcingMeshTypeEnum_ val) { if (val < kIfcReinforcingMeshTypeEnum_unset) m_val = val; else m_val = kIfcReinforcingMeshTypeEnum_unset; return *this; };

  bool operator == (const IfcReinforcingMeshTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcReinforcingMeshTypeEnum &in);

IfcReinforcingMeshTypeEnum StrToIfcReinforcingMeshTypeEnum(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_COMMISSIONINGENGINEER,

  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_USERDEFINED,

  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_COSENSOR,

  kIfcSensorTypeEnum_CO2SENSOR,

  kIfcSensorTypeEnum_CONDUCTANCESENSOR,

  kIfcSensorTypeEnum_CONTACTSENSOR,

  kIfcSensorTypeEnum_FIRESENSOR,

  kIfcSensorTypeEnum_FLOWSENSOR,

  kIfcSensorTypeEnum_FROSTSENSOR,

  kIfcSensorTypeEnum_GASSENSOR,

  kIfcSensorTypeEnum_HEATSENSOR,

  kIfcSensorTypeEnum_HUMIDITYSENSOR,

  kIfcSensorTypeEnum_IDENTIFIERSENSOR,

  kIfcSensorTypeEnum_IONCONCENTRATIONSENSOR,

  kIfcSensorTypeEnum_LEVELSENSOR,

  kIfcSensorTypeEnum_LIGHTSENSOR,

  kIfcSensorTypeEnum_MOISTURESENSOR,

  kIfcSensorTypeEnum_MOVEMENTSENSOR,

  kIfcSensorTypeEnum_PHSENSOR,

  kIfcSensorTypeEnum_PRESSURESENSOR,

  kIfcSensorTypeEnum_RADIATIONSENSOR,

  kIfcSensorTypeEnum_RADIOACTIVITYSENSOR,

  kIfcSensorTypeEnum_SMOKESENSOR,

  kIfcSensorTypeEnum_SOUNDSENSOR,

  kIfcSensorTypeEnum_TEMPERATURESENSOR,

  kIfcSensorTypeEnum_WINDSENSOR,

  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_USERDEFINED,

  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 IfcShadingDeviceTypeEnum_

{

  kIfcShadingDeviceTypeEnum_JALOUSIE,

  kIfcShadingDeviceTypeEnum_SHUTTER,

  kIfcShadingDeviceTypeEnum_AWNING,

  kIfcShadingDeviceTypeEnum_USERDEFINED,

  kIfcShadingDeviceTypeEnum_NOTDEFINED,

  kIfcShadingDeviceTypeEnum_unset

};


class IfcShadingDeviceTypeEnum {

  IfcShadingDeviceTypeEnum_ m_val;

public:

  IfcShadingDeviceTypeEnum() : m_val(kIfcShadingDeviceTypeEnum_unset) {};

  IfcShadingDeviceTypeEnum(const IfcShadingDeviceTypeEnum &other) : m_val(other.m_val) {};

  IfcShadingDeviceTypeEnum(IfcShadingDeviceTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcShadingDeviceTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcShadingDeviceTypeEnum_unset; };

  operator IfcShadingDeviceTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcShadingDeviceTypeEnum& operator = (const IfcShadingDeviceTypeEnum_ val) { if (val < kIfcShadingDeviceTypeEnum_unset) m_val = val; else m_val = kIfcShadingDeviceTypeEnum_unset; return *this; };

  bool operator == (const IfcShadingDeviceTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcShadingDeviceTypeEnum &in);

IfcShadingDeviceTypeEnum StrToIfcShadingDeviceTypeEnum(OdAnsiString val);

enum IfcSimplePropertyTemplateTypeEnum_

{

  kIfcSimplePropertyTemplateTypeEnum_P_SINGLEVALUE,

  kIfcSimplePropertyTemplateTypeEnum_P_ENUMERATEDVALUE,

  kIfcSimplePropertyTemplateTypeEnum_P_BOUNDEDVALUE,

  kIfcSimplePropertyTemplateTypeEnum_P_LISTVALUE,

  kIfcSimplePropertyTemplateTypeEnum_P_TABLEVALUE,

  kIfcSimplePropertyTemplateTypeEnum_P_REFERENCEVALUE,

  kIfcSimplePropertyTemplateTypeEnum_Q_LENGTH,

  kIfcSimplePropertyTemplateTypeEnum_Q_AREA,

  kIfcSimplePropertyTemplateTypeEnum_Q_VOLUME,

  kIfcSimplePropertyTemplateTypeEnum_Q_COUNT,

  kIfcSimplePropertyTemplateTypeEnum_Q_WEIGHT,

  kIfcSimplePropertyTemplateTypeEnum_Q_TIME,

  kIfcSimplePropertyTemplateTypeEnum_unset

};


class IfcSimplePropertyTemplateTypeEnum {

  IfcSimplePropertyTemplateTypeEnum_ m_val;

public:

  IfcSimplePropertyTemplateTypeEnum() : m_val(kIfcSimplePropertyTemplateTypeEnum_unset) {};

  IfcSimplePropertyTemplateTypeEnum(const IfcSimplePropertyTemplateTypeEnum &other) : m_val(other.m_val) {};

  IfcSimplePropertyTemplateTypeEnum(IfcSimplePropertyTemplateTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcSimplePropertyTemplateTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcSimplePropertyTemplateTypeEnum_unset; };

  operator IfcSimplePropertyTemplateTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcSimplePropertyTemplateTypeEnum& operator = (const IfcSimplePropertyTemplateTypeEnum_ val) { if (val < kIfcSimplePropertyTemplateTypeEnum_unset) m_val = val; else m_val = kIfcSimplePropertyTemplateTypeEnum_unset; return *this; };

  bool operator == (const IfcSimplePropertyTemplateTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcSimplePropertyTemplateTypeEnum &in);

IfcSimplePropertyTemplateTypeEnum StrToIfcSimplePropertyTemplateTypeEnum(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 IfcSolarDeviceTypeEnum_

{

  kIfcSolarDeviceTypeEnum_SOLARCOLLECTOR,

  kIfcSolarDeviceTypeEnum_SOLARPANEL,

  kIfcSolarDeviceTypeEnum_USERDEFINED,

  kIfcSolarDeviceTypeEnum_NOTDEFINED,

  kIfcSolarDeviceTypeEnum_unset

};


class IfcSolarDeviceTypeEnum {

  IfcSolarDeviceTypeEnum_ m_val;

public:

  IfcSolarDeviceTypeEnum() : m_val(kIfcSolarDeviceTypeEnum_unset) {};

  IfcSolarDeviceTypeEnum(const IfcSolarDeviceTypeEnum &other) : m_val(other.m_val) {};

  IfcSolarDeviceTypeEnum(IfcSolarDeviceTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcSolarDeviceTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcSolarDeviceTypeEnum_unset; };

  operator IfcSolarDeviceTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcSolarDeviceTypeEnum& operator = (const IfcSolarDeviceTypeEnum_ val) { if (val < kIfcSolarDeviceTypeEnum_unset) m_val = val; else m_val = kIfcSolarDeviceTypeEnum_unset; return *this; };

  bool operator == (const IfcSolarDeviceTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcSolarDeviceTypeEnum &in);

IfcSolarDeviceTypeEnum StrToIfcSolarDeviceTypeEnum(OdAnsiString val);

enum IfcSpaceHeaterTypeEnum_

{

  kIfcSpaceHeaterTypeEnum_CONVECTOR,

  kIfcSpaceHeaterTypeEnum_RADIATOR,

  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_SPACE,

  kIfcSpaceTypeEnum_PARKING,

  kIfcSpaceTypeEnum_GFA,

  kIfcSpaceTypeEnum_INTERNAL,

  kIfcSpaceTypeEnum_EXTERNAL,

  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 IfcSpatialZoneTypeEnum_

{

  kIfcSpatialZoneTypeEnum_CONSTRUCTION,

  kIfcSpatialZoneTypeEnum_FIRESAFETY,

  kIfcSpatialZoneTypeEnum_LIGHTING,

  kIfcSpatialZoneTypeEnum_OCCUPANCY,

  kIfcSpatialZoneTypeEnum_SECURITY,

  kIfcSpatialZoneTypeEnum_THERMAL,

  kIfcSpatialZoneTypeEnum_TRANSPORT,

  kIfcSpatialZoneTypeEnum_VENTILATION,

  kIfcSpatialZoneTypeEnum_USERDEFINED,

  kIfcSpatialZoneTypeEnum_NOTDEFINED,

  kIfcSpatialZoneTypeEnum_unset

};


class IfcSpatialZoneTypeEnum {

  IfcSpatialZoneTypeEnum_ m_val;

public:

  IfcSpatialZoneTypeEnum() : m_val(kIfcSpatialZoneTypeEnum_unset) {};

  IfcSpatialZoneTypeEnum(const IfcSpatialZoneTypeEnum &other) : m_val(other.m_val) {};

  IfcSpatialZoneTypeEnum(IfcSpatialZoneTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcSpatialZoneTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcSpatialZoneTypeEnum_unset; };

  operator IfcSpatialZoneTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcSpatialZoneTypeEnum& operator = (const IfcSpatialZoneTypeEnum_ val) { if (val < kIfcSpatialZoneTypeEnum_unset) m_val = val; else m_val = kIfcSpatialZoneTypeEnum_unset; return *this; };

  bool operator == (const IfcSpatialZoneTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcSpatialZoneTypeEnum &in);

IfcSpatialZoneTypeEnum StrToIfcSpatialZoneTypeEnum(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 IfcStructuralCurveActivityTypeEnum_

{

  kIfcStructuralCurveActivityTypeEnum_CONST,

  kIfcStructuralCurveActivityTypeEnum_LINEAR,

  kIfcStructuralCurveActivityTypeEnum_POLYGONAL,

  kIfcStructuralCurveActivityTypeEnum_EQUIDISTANT,

  kIfcStructuralCurveActivityTypeEnum_SINUS,

  kIfcStructuralCurveActivityTypeEnum_PARABOLA,

  kIfcStructuralCurveActivityTypeEnum_DISCRETE,

  kIfcStructuralCurveActivityTypeEnum_USERDEFINED,

  kIfcStructuralCurveActivityTypeEnum_NOTDEFINED,

  kIfcStructuralCurveActivityTypeEnum_unset

};


class IfcStructuralCurveActivityTypeEnum {

  IfcStructuralCurveActivityTypeEnum_ m_val;

public:

  IfcStructuralCurveActivityTypeEnum() : m_val(kIfcStructuralCurveActivityTypeEnum_unset) {};

  IfcStructuralCurveActivityTypeEnum(const IfcStructuralCurveActivityTypeEnum &other) : m_val(other.m_val) {};

  IfcStructuralCurveActivityTypeEnum(IfcStructuralCurveActivityTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcStructuralCurveActivityTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcStructuralCurveActivityTypeEnum_unset; };

  operator IfcStructuralCurveActivityTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcStructuralCurveActivityTypeEnum& operator = (const IfcStructuralCurveActivityTypeEnum_ val) { if (val < kIfcStructuralCurveActivityTypeEnum_unset) m_val = val; else m_val = kIfcStructuralCurveActivityTypeEnum_unset; return *this; };

  bool operator == (const IfcStructuralCurveActivityTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcStructuralCurveActivityTypeEnum &in);

IfcStructuralCurveActivityTypeEnum StrToIfcStructuralCurveActivityTypeEnum(OdAnsiString val);

enum IfcStructuralCurveMemberTypeEnum_

{

  kIfcStructuralCurveMemberTypeEnum_RIGID_JOINED_MEMBER,

  kIfcStructuralCurveMemberTypeEnum_PIN_JOINED_MEMBER,

  kIfcStructuralCurveMemberTypeEnum_CABLE,

  kIfcStructuralCurveMemberTypeEnum_TENSION_MEMBER,

  kIfcStructuralCurveMemberTypeEnum_COMPRESSION_MEMBER,

  kIfcStructuralCurveMemberTypeEnum_USERDEFINED,

  kIfcStructuralCurveMemberTypeEnum_NOTDEFINED,

  kIfcStructuralCurveMemberTypeEnum_unset

};


class IfcStructuralCurveMemberTypeEnum {

  IfcStructuralCurveMemberTypeEnum_ m_val;

public:

  IfcStructuralCurveMemberTypeEnum() : m_val(kIfcStructuralCurveMemberTypeEnum_unset) {};

  IfcStructuralCurveMemberTypeEnum(const IfcStructuralCurveMemberTypeEnum &other) : m_val(other.m_val) {};

  IfcStructuralCurveMemberTypeEnum(IfcStructuralCurveMemberTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcStructuralCurveMemberTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcStructuralCurveMemberTypeEnum_unset; };

  operator IfcStructuralCurveMemberTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcStructuralCurveMemberTypeEnum& operator = (const IfcStructuralCurveMemberTypeEnum_ val) { if (val < kIfcStructuralCurveMemberTypeEnum_unset) m_val = val; else m_val = kIfcStructuralCurveMemberTypeEnum_unset; return *this; };

  bool operator == (const IfcStructuralCurveMemberTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcStructuralCurveMemberTypeEnum &in);

IfcStructuralCurveMemberTypeEnum StrToIfcStructuralCurveMemberTypeEnum(OdAnsiString val);

enum IfcStructuralSurfaceActivityTypeEnum_

{

  kIfcStructuralSurfaceActivityTypeEnum_CONST,

  kIfcStructuralSurfaceActivityTypeEnum_BILINEAR,

  kIfcStructuralSurfaceActivityTypeEnum_DISCRETE,

  kIfcStructuralSurfaceActivityTypeEnum_ISOCONTOUR,

  kIfcStructuralSurfaceActivityTypeEnum_USERDEFINED,

  kIfcStructuralSurfaceActivityTypeEnum_NOTDEFINED,

  kIfcStructuralSurfaceActivityTypeEnum_unset

};


class IfcStructuralSurfaceActivityTypeEnum {

  IfcStructuralSurfaceActivityTypeEnum_ m_val;

public:

  IfcStructuralSurfaceActivityTypeEnum() : m_val(kIfcStructuralSurfaceActivityTypeEnum_unset) {};

  IfcStructuralSurfaceActivityTypeEnum(const IfcStructuralSurfaceActivityTypeEnum &other) : m_val(other.m_val) {};

  IfcStructuralSurfaceActivityTypeEnum(IfcStructuralSurfaceActivityTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcStructuralSurfaceActivityTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcStructuralSurfaceActivityTypeEnum_unset; };

  operator IfcStructuralSurfaceActivityTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcStructuralSurfaceActivityTypeEnum& operator = (const IfcStructuralSurfaceActivityTypeEnum_ val) { if (val < kIfcStructuralSurfaceActivityTypeEnum_unset) m_val = val; else m_val = kIfcStructuralSurfaceActivityTypeEnum_unset; return *this; };

  bool operator == (const IfcStructuralSurfaceActivityTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcStructuralSurfaceActivityTypeEnum &in);

IfcStructuralSurfaceActivityTypeEnum StrToIfcStructuralSurfaceActivityTypeEnum(OdAnsiString val);

enum IfcStructuralSurfaceMemberTypeEnum_

{

  kIfcStructuralSurfaceMemberTypeEnum_BENDING_ELEMENT,

  kIfcStructuralSurfaceMemberTypeEnum_MEMBRANE_ELEMENT,

  kIfcStructuralSurfaceMemberTypeEnum_SHELL,

  kIfcStructuralSurfaceMemberTypeEnum_USERDEFINED,

  kIfcStructuralSurfaceMemberTypeEnum_NOTDEFINED,

  kIfcStructuralSurfaceMemberTypeEnum_unset

};


class IfcStructuralSurfaceMemberTypeEnum {

  IfcStructuralSurfaceMemberTypeEnum_ m_val;

public:

  IfcStructuralSurfaceMemberTypeEnum() : m_val(kIfcStructuralSurfaceMemberTypeEnum_unset) {};

  IfcStructuralSurfaceMemberTypeEnum(const IfcStructuralSurfaceMemberTypeEnum &other) : m_val(other.m_val) {};

  IfcStructuralSurfaceMemberTypeEnum(IfcStructuralSurfaceMemberTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcStructuralSurfaceMemberTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcStructuralSurfaceMemberTypeEnum_unset; };

  operator IfcStructuralSurfaceMemberTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcStructuralSurfaceMemberTypeEnum& operator = (const IfcStructuralSurfaceMemberTypeEnum_ val) { if (val < kIfcStructuralSurfaceMemberTypeEnum_unset) m_val = val; else m_val = kIfcStructuralSurfaceMemberTypeEnum_unset; return *this; };

  bool operator == (const IfcStructuralSurfaceMemberTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcStructuralSurfaceMemberTypeEnum &in);

IfcStructuralSurfaceMemberTypeEnum StrToIfcStructuralSurfaceMemberTypeEnum(OdAnsiString val);

enum IfcSubContractResourceTypeEnum_

{

  kIfcSubContractResourceTypeEnum_PURCHASE,

  kIfcSubContractResourceTypeEnum_WORK,

  kIfcSubContractResourceTypeEnum_USERDEFINED,

  kIfcSubContractResourceTypeEnum_NOTDEFINED,

  kIfcSubContractResourceTypeEnum_unset

};


class IfcSubContractResourceTypeEnum {

  IfcSubContractResourceTypeEnum_ m_val;

public:

  IfcSubContractResourceTypeEnum() : m_val(kIfcSubContractResourceTypeEnum_unset) {};

  IfcSubContractResourceTypeEnum(const IfcSubContractResourceTypeEnum &other) : m_val(other.m_val) {};

  IfcSubContractResourceTypeEnum(IfcSubContractResourceTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcSubContractResourceTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcSubContractResourceTypeEnum_unset; };

  operator IfcSubContractResourceTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcSubContractResourceTypeEnum& operator = (const IfcSubContractResourceTypeEnum_ val) { if (val < kIfcSubContractResourceTypeEnum_unset) m_val = val; else m_val = kIfcSubContractResourceTypeEnum_unset; return *this; };

  bool operator == (const IfcSubContractResourceTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcSubContractResourceTypeEnum &in);

IfcSubContractResourceTypeEnum StrToIfcSubContractResourceTypeEnum(OdAnsiString val);

enum IfcSurfaceFeatureTypeEnum_

{

  kIfcSurfaceFeatureTypeEnum_MARK,

  kIfcSurfaceFeatureTypeEnum_TAG,

  kIfcSurfaceFeatureTypeEnum_TREATMENT,

  kIfcSurfaceFeatureTypeEnum_USERDEFINED,

  kIfcSurfaceFeatureTypeEnum_NOTDEFINED,

  kIfcSurfaceFeatureTypeEnum_unset

};


class IfcSurfaceFeatureTypeEnum {

  IfcSurfaceFeatureTypeEnum_ m_val;

public:

  IfcSurfaceFeatureTypeEnum() : m_val(kIfcSurfaceFeatureTypeEnum_unset) {};

  IfcSurfaceFeatureTypeEnum(const IfcSurfaceFeatureTypeEnum &other) : m_val(other.m_val) {};

  IfcSurfaceFeatureTypeEnum(IfcSurfaceFeatureTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcSurfaceFeatureTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcSurfaceFeatureTypeEnum_unset; };

  operator IfcSurfaceFeatureTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcSurfaceFeatureTypeEnum& operator = (const IfcSurfaceFeatureTypeEnum_ val) { if (val < kIfcSurfaceFeatureTypeEnum_unset) m_val = val; else m_val = kIfcSurfaceFeatureTypeEnum_unset; return *this; };

  bool operator == (const IfcSurfaceFeatureTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcSurfaceFeatureTypeEnum &in);

IfcSurfaceFeatureTypeEnum StrToIfcSurfaceFeatureTypeEnum(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 IfcSwitchingDeviceTypeEnum_

{

  kIfcSwitchingDeviceTypeEnum_CONTACTOR,

  kIfcSwitchingDeviceTypeEnum_DIMMERSWITCH,

  kIfcSwitchingDeviceTypeEnum_EMERGENCYSTOP,

  kIfcSwitchingDeviceTypeEnum_KEYPAD,

  kIfcSwitchingDeviceTypeEnum_MOMENTARYSWITCH,

  kIfcSwitchingDeviceTypeEnum_SELECTORSWITCH,

  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 IfcSystemFurnitureElementTypeEnum_

{

  kIfcSystemFurnitureElementTypeEnum_PANEL,

  kIfcSystemFurnitureElementTypeEnum_WORKSURFACE,

  kIfcSystemFurnitureElementTypeEnum_USERDEFINED,

  kIfcSystemFurnitureElementTypeEnum_NOTDEFINED,

  kIfcSystemFurnitureElementTypeEnum_unset

};


class IfcSystemFurnitureElementTypeEnum {

  IfcSystemFurnitureElementTypeEnum_ m_val;

public:

  IfcSystemFurnitureElementTypeEnum() : m_val(kIfcSystemFurnitureElementTypeEnum_unset) {};

  IfcSystemFurnitureElementTypeEnum(const IfcSystemFurnitureElementTypeEnum &other) : m_val(other.m_val) {};

  IfcSystemFurnitureElementTypeEnum(IfcSystemFurnitureElementTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcSystemFurnitureElementTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcSystemFurnitureElementTypeEnum_unset; };

  operator IfcSystemFurnitureElementTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcSystemFurnitureElementTypeEnum& operator = (const IfcSystemFurnitureElementTypeEnum_ val) { if (val < kIfcSystemFurnitureElementTypeEnum_unset) m_val = val; else m_val = kIfcSystemFurnitureElementTypeEnum_unset; return *this; };

  bool operator == (const IfcSystemFurnitureElementTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcSystemFurnitureElementTypeEnum &in);

IfcSystemFurnitureElementTypeEnum StrToIfcSystemFurnitureElementTypeEnum(OdAnsiString val);

enum IfcTankTypeEnum_

{

  kIfcTankTypeEnum_BASIN,

  kIfcTankTypeEnum_BREAKPRESSURE,

  kIfcTankTypeEnum_EXPANSION,

  kIfcTankTypeEnum_FEEDANDEXPANSION,

  kIfcTankTypeEnum_PRESSUREVESSEL,

  kIfcTankTypeEnum_STORAGE,

  kIfcTankTypeEnum_VESSEL,

  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 IfcTaskDurationEnum_

{

  kIfcTaskDurationEnum_ELAPSEDTIME,

  kIfcTaskDurationEnum_WORKTIME,

  kIfcTaskDurationEnum_NOTDEFINED,

  kIfcTaskDurationEnum_unset

};


class IfcTaskDurationEnum {

  IfcTaskDurationEnum_ m_val;

public:

  IfcTaskDurationEnum() : m_val(kIfcTaskDurationEnum_unset) {};

  IfcTaskDurationEnum(const IfcTaskDurationEnum &other) : m_val(other.m_val) {};

  IfcTaskDurationEnum(IfcTaskDurationEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcTaskDurationEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcTaskDurationEnum_unset; };

  operator IfcTaskDurationEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcTaskDurationEnum& operator = (const IfcTaskDurationEnum_ val) { if (val < kIfcTaskDurationEnum_unset) m_val = val; else m_val = kIfcTaskDurationEnum_unset; return *this; };

  bool operator == (const IfcTaskDurationEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcTaskDurationEnum &in);

IfcTaskDurationEnum StrToIfcTaskDurationEnum(OdAnsiString val);

enum IfcTaskTypeEnum_

{

  kIfcTaskTypeEnum_ATTENDANCE,

  kIfcTaskTypeEnum_CONSTRUCTION,

  kIfcTaskTypeEnum_DEMOLITION,

  kIfcTaskTypeEnum_DISMANTLE,

  kIfcTaskTypeEnum_DISPOSAL,

  kIfcTaskTypeEnum_INSTALLATION,

  kIfcTaskTypeEnum_LOGISTIC,

  kIfcTaskTypeEnum_MAINTENANCE,

  kIfcTaskTypeEnum_MOVE,

  kIfcTaskTypeEnum_OPERATION,

  kIfcTaskTypeEnum_REMOVAL,

  kIfcTaskTypeEnum_RENOVATION,

  kIfcTaskTypeEnum_USERDEFINED,

  kIfcTaskTypeEnum_NOTDEFINED,

  kIfcTaskTypeEnum_unset

};


class IfcTaskTypeEnum {

  IfcTaskTypeEnum_ m_val;

public:

  IfcTaskTypeEnum() : m_val(kIfcTaskTypeEnum_unset) {};

  IfcTaskTypeEnum(const IfcTaskTypeEnum &other) : m_val(other.m_val) {};

  IfcTaskTypeEnum(IfcTaskTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcTaskTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcTaskTypeEnum_unset; };

  operator IfcTaskTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcTaskTypeEnum& operator = (const IfcTaskTypeEnum_ val) { if (val < kIfcTaskTypeEnum_unset) m_val = val; else m_val = kIfcTaskTypeEnum_unset; return *this; };

  bool operator == (const IfcTaskTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcTaskTypeEnum &in);

IfcTaskTypeEnum StrToIfcTaskTypeEnum(OdAnsiString val);

enum IfcTendonAnchorTypeEnum_

{

  kIfcTendonAnchorTypeEnum_COUPLER,

  kIfcTendonAnchorTypeEnum_FIXED_END,

  kIfcTendonAnchorTypeEnum_TENSIONING_END,

  kIfcTendonAnchorTypeEnum_USERDEFINED,

  kIfcTendonAnchorTypeEnum_NOTDEFINED,

  kIfcTendonAnchorTypeEnum_unset

};


class IfcTendonAnchorTypeEnum {

  IfcTendonAnchorTypeEnum_ m_val;

public:

  IfcTendonAnchorTypeEnum() : m_val(kIfcTendonAnchorTypeEnum_unset) {};

  IfcTendonAnchorTypeEnum(const IfcTendonAnchorTypeEnum &other) : m_val(other.m_val) {};

  IfcTendonAnchorTypeEnum(IfcTendonAnchorTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcTendonAnchorTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcTendonAnchorTypeEnum_unset; };

  operator IfcTendonAnchorTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcTendonAnchorTypeEnum& operator = (const IfcTendonAnchorTypeEnum_ val) { if (val < kIfcTendonAnchorTypeEnum_unset) m_val = val; else m_val = kIfcTendonAnchorTypeEnum_unset; return *this; };

  bool operator == (const IfcTendonAnchorTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcTendonAnchorTypeEnum &in);

IfcTendonAnchorTypeEnum StrToIfcTendonAnchorTypeEnum(OdAnsiString val);

enum IfcTendonTypeEnum_

{

  kIfcTendonTypeEnum_BAR,

  kIfcTendonTypeEnum_COATED,

  kIfcTendonTypeEnum_STRAND,

  kIfcTendonTypeEnum_WIRE,

  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 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 IfcTransformerTypeEnum_

{

  kIfcTransformerTypeEnum_CURRENT,

  kIfcTransformerTypeEnum_FREQUENCY,

  kIfcTransformerTypeEnum_INVERTER,

  kIfcTransformerTypeEnum_RECTIFIER,

  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_CRANEWAY,

  kIfcTransportElementTypeEnum_LIFTINGGEAR,

  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 IfcUnitaryControlElementTypeEnum_

{

  kIfcUnitaryControlElementTypeEnum_ALARMPANEL,

  kIfcUnitaryControlElementTypeEnum_CONTROLPANEL,

  kIfcUnitaryControlElementTypeEnum_GASDETECTIONPANEL,

  kIfcUnitaryControlElementTypeEnum_INDICATORPANEL,

  kIfcUnitaryControlElementTypeEnum_MIMICPANEL,

  kIfcUnitaryControlElementTypeEnum_HUMIDISTAT,

  kIfcUnitaryControlElementTypeEnum_THERMOSTAT,

  kIfcUnitaryControlElementTypeEnum_WEATHERSTATION,

  kIfcUnitaryControlElementTypeEnum_USERDEFINED,

  kIfcUnitaryControlElementTypeEnum_NOTDEFINED,

  kIfcUnitaryControlElementTypeEnum_unset

};


class IfcUnitaryControlElementTypeEnum {

  IfcUnitaryControlElementTypeEnum_ m_val;

public:

  IfcUnitaryControlElementTypeEnum() : m_val(kIfcUnitaryControlElementTypeEnum_unset) {};

  IfcUnitaryControlElementTypeEnum(const IfcUnitaryControlElementTypeEnum &other) : m_val(other.m_val) {};

  IfcUnitaryControlElementTypeEnum(IfcUnitaryControlElementTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcUnitaryControlElementTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcUnitaryControlElementTypeEnum_unset; };

  operator IfcUnitaryControlElementTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcUnitaryControlElementTypeEnum& operator = (const IfcUnitaryControlElementTypeEnum_ val) { if (val < kIfcUnitaryControlElementTypeEnum_unset) m_val = val; else m_val = kIfcUnitaryControlElementTypeEnum_unset; return *this; };

  bool operator == (const IfcUnitaryControlElementTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcUnitaryControlElementTypeEnum &in);

IfcUnitaryControlElementTypeEnum StrToIfcUnitaryControlElementTypeEnum(OdAnsiString val);

enum IfcUnitaryEquipmentTypeEnum_

{

  kIfcUnitaryEquipmentTypeEnum_AIRHANDLER,

  kIfcUnitaryEquipmentTypeEnum_AIRCONDITIONINGUNIT,

  kIfcUnitaryEquipmentTypeEnum_DEHUMIDIFIER,

  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 IfcVoidingFeatureTypeEnum_

{

  kIfcVoidingFeatureTypeEnum_CUTOUT,

  kIfcVoidingFeatureTypeEnum_NOTCH,

  kIfcVoidingFeatureTypeEnum_HOLE,

  kIfcVoidingFeatureTypeEnum_MITER,

  kIfcVoidingFeatureTypeEnum_CHAMFER,

  kIfcVoidingFeatureTypeEnum_EDGE,

  kIfcVoidingFeatureTypeEnum_USERDEFINED,

  kIfcVoidingFeatureTypeEnum_NOTDEFINED,

  kIfcVoidingFeatureTypeEnum_unset

};


class IfcVoidingFeatureTypeEnum {

  IfcVoidingFeatureTypeEnum_ m_val;

public:

  IfcVoidingFeatureTypeEnum() : m_val(kIfcVoidingFeatureTypeEnum_unset) {};

  IfcVoidingFeatureTypeEnum(const IfcVoidingFeatureTypeEnum &other) : m_val(other.m_val) {};

  IfcVoidingFeatureTypeEnum(IfcVoidingFeatureTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcVoidingFeatureTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcVoidingFeatureTypeEnum_unset; };

  operator IfcVoidingFeatureTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcVoidingFeatureTypeEnum& operator = (const IfcVoidingFeatureTypeEnum_ val) { if (val < kIfcVoidingFeatureTypeEnum_unset) m_val = val; else m_val = kIfcVoidingFeatureTypeEnum_unset; return *this; };

  bool operator == (const IfcVoidingFeatureTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcVoidingFeatureTypeEnum &in);

IfcVoidingFeatureTypeEnum StrToIfcVoidingFeatureTypeEnum(OdAnsiString val);

enum IfcWallTypeEnum_

{

  kIfcWallTypeEnum_MOVABLE,

  kIfcWallTypeEnum_PARAPET,

  kIfcWallTypeEnum_PARTITIONING,

  kIfcWallTypeEnum_PLUMBINGWALL,

  kIfcWallTypeEnum_SHEAR,

  kIfcWallTypeEnum_SOLIDWALL,

  kIfcWallTypeEnum_STANDARD,

  kIfcWallTypeEnum_POLYGONAL,

  kIfcWallTypeEnum_ELEMENTEDWALL,

  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_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 IfcWindowTypeEnum_

{

  kIfcWindowTypeEnum_WINDOW,

  kIfcWindowTypeEnum_SKYLIGHT,

  kIfcWindowTypeEnum_LIGHTDOME,

  kIfcWindowTypeEnum_USERDEFINED,

  kIfcWindowTypeEnum_NOTDEFINED,

  kIfcWindowTypeEnum_unset

};


class IfcWindowTypeEnum {

  IfcWindowTypeEnum_ m_val;

public:

  IfcWindowTypeEnum() : m_val(kIfcWindowTypeEnum_unset) {};

  IfcWindowTypeEnum(const IfcWindowTypeEnum &other) : m_val(other.m_val) {};

  IfcWindowTypeEnum(IfcWindowTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcWindowTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcWindowTypeEnum_unset; };

  operator IfcWindowTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcWindowTypeEnum& operator = (const IfcWindowTypeEnum_ val) { if (val < kIfcWindowTypeEnum_unset) m_val = val; else m_val = kIfcWindowTypeEnum_unset; return *this; };

  bool operator == (const IfcWindowTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcWindowTypeEnum &in);

IfcWindowTypeEnum StrToIfcWindowTypeEnum(OdAnsiString val);

enum IfcWindowTypePartitioningEnum_

{

  kIfcWindowTypePartitioningEnum_SINGLE_PANEL,

  kIfcWindowTypePartitioningEnum_DOUBLE_PANEL_VERTICAL,

  kIfcWindowTypePartitioningEnum_DOUBLE_PANEL_HORIZONTAL,

  kIfcWindowTypePartitioningEnum_TRIPLE_PANEL_VERTICAL,

  kIfcWindowTypePartitioningEnum_TRIPLE_PANEL_BOTTOM,

  kIfcWindowTypePartitioningEnum_TRIPLE_PANEL_TOP,

  kIfcWindowTypePartitioningEnum_TRIPLE_PANEL_LEFT,

  kIfcWindowTypePartitioningEnum_TRIPLE_PANEL_RIGHT,

  kIfcWindowTypePartitioningEnum_TRIPLE_PANEL_HORIZONTAL,

  kIfcWindowTypePartitioningEnum_USERDEFINED,

  kIfcWindowTypePartitioningEnum_NOTDEFINED,

  kIfcWindowTypePartitioningEnum_unset

};


class IfcWindowTypePartitioningEnum {

  IfcWindowTypePartitioningEnum_ m_val;

public:

  IfcWindowTypePartitioningEnum() : m_val(kIfcWindowTypePartitioningEnum_unset) {};

  IfcWindowTypePartitioningEnum(const IfcWindowTypePartitioningEnum &other) : m_val(other.m_val) {};

  IfcWindowTypePartitioningEnum(IfcWindowTypePartitioningEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcWindowTypePartitioningEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcWindowTypePartitioningEnum_unset; };

  operator IfcWindowTypePartitioningEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcWindowTypePartitioningEnum& operator = (const IfcWindowTypePartitioningEnum_ val) { if (val < kIfcWindowTypePartitioningEnum_unset) m_val = val; else m_val = kIfcWindowTypePartitioningEnum_unset; return *this; };

  bool operator == (const IfcWindowTypePartitioningEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcWindowTypePartitioningEnum &in);

IfcWindowTypePartitioningEnum StrToIfcWindowTypePartitioningEnum(OdAnsiString val);

enum IfcWorkCalendarTypeEnum_

{

  kIfcWorkCalendarTypeEnum_FIRSTSHIFT,

  kIfcWorkCalendarTypeEnum_SECONDSHIFT,

  kIfcWorkCalendarTypeEnum_THIRDSHIFT,

  kIfcWorkCalendarTypeEnum_USERDEFINED,

  kIfcWorkCalendarTypeEnum_NOTDEFINED,

  kIfcWorkCalendarTypeEnum_unset

};


class IfcWorkCalendarTypeEnum {

  IfcWorkCalendarTypeEnum_ m_val;

public:

  IfcWorkCalendarTypeEnum() : m_val(kIfcWorkCalendarTypeEnum_unset) {};

  IfcWorkCalendarTypeEnum(const IfcWorkCalendarTypeEnum &other) : m_val(other.m_val) {};

  IfcWorkCalendarTypeEnum(IfcWorkCalendarTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcWorkCalendarTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcWorkCalendarTypeEnum_unset; };

  operator IfcWorkCalendarTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcWorkCalendarTypeEnum& operator = (const IfcWorkCalendarTypeEnum_ val) { if (val < kIfcWorkCalendarTypeEnum_unset) m_val = val; else m_val = kIfcWorkCalendarTypeEnum_unset; return *this; };

  bool operator == (const IfcWorkCalendarTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcWorkCalendarTypeEnum &in);

IfcWorkCalendarTypeEnum StrToIfcWorkCalendarTypeEnum(OdAnsiString val);

enum IfcWorkPlanTypeEnum_

{

  kIfcWorkPlanTypeEnum_ACTUAL,

  kIfcWorkPlanTypeEnum_BASELINE,

  kIfcWorkPlanTypeEnum_PLANNED,

  kIfcWorkPlanTypeEnum_USERDEFINED,

  kIfcWorkPlanTypeEnum_NOTDEFINED,

  kIfcWorkPlanTypeEnum_unset

};


class IfcWorkPlanTypeEnum {

  IfcWorkPlanTypeEnum_ m_val;

public:

  IfcWorkPlanTypeEnum() : m_val(kIfcWorkPlanTypeEnum_unset) {};

  IfcWorkPlanTypeEnum(const IfcWorkPlanTypeEnum &other) : m_val(other.m_val) {};

  IfcWorkPlanTypeEnum(IfcWorkPlanTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcWorkPlanTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcWorkPlanTypeEnum_unset; };

  operator IfcWorkPlanTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcWorkPlanTypeEnum& operator = (const IfcWorkPlanTypeEnum_ val) { if (val < kIfcWorkPlanTypeEnum_unset) m_val = val; else m_val = kIfcWorkPlanTypeEnum_unset; return *this; };

  bool operator == (const IfcWorkPlanTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcWorkPlanTypeEnum &in);

IfcWorkPlanTypeEnum StrToIfcWorkPlanTypeEnum(OdAnsiString val);

enum IfcWorkScheduleTypeEnum_

{

  kIfcWorkScheduleTypeEnum_ACTUAL,

  kIfcWorkScheduleTypeEnum_BASELINE,

  kIfcWorkScheduleTypeEnum_PLANNED,

  kIfcWorkScheduleTypeEnum_USERDEFINED,

  kIfcWorkScheduleTypeEnum_NOTDEFINED,

  kIfcWorkScheduleTypeEnum_unset

};


class IfcWorkScheduleTypeEnum {

  IfcWorkScheduleTypeEnum_ m_val;

public:

  IfcWorkScheduleTypeEnum() : m_val(kIfcWorkScheduleTypeEnum_unset) {};

  IfcWorkScheduleTypeEnum(const IfcWorkScheduleTypeEnum &other) : m_val(other.m_val) {};

  IfcWorkScheduleTypeEnum(IfcWorkScheduleTypeEnum_ val) : m_val(val) {};

  int exists() const { return m_val != kIfcWorkScheduleTypeEnum_unset ? 1 : 0; };

  void nullify() { m_val = kIfcWorkScheduleTypeEnum_unset; };

  operator IfcWorkScheduleTypeEnum_() const { return m_val; };

  operator unsigned long () const { return (unsigned long)m_val; };

  IfcWorkScheduleTypeEnum& operator = (const IfcWorkScheduleTypeEnum_ val) { if (val < kIfcWorkScheduleTypeEnum_unset) m_val = val; else m_val = kIfcWorkScheduleTypeEnum_unset; return *this; };

  bool operator == (const IfcWorkScheduleTypeEnum &other) const { return m_val == other.m_val; };

  OdAnsiString toStr();


};


bool operator>> (const OdRxValue &out, IfcWorkScheduleTypeEnum &in);

IfcWorkScheduleTypeEnum StrToIfcWorkScheduleTypeEnum(OdAnsiString val);


} // namespace


#endif // _IFC4_ENUM_4_H