/********************************************************************************
 *                                                                              *
 * This file is part of IfcOpenShell.                                           *
 *                                                                              *
 * IfcOpenShell is free software: you can redistribute it and/or modify         *
 * it under the terms of the Lesser GNU General Public License as published by  *
 * the Free Software Foundation, either version 3.0 of the License, or          *
 * (at your option) any later version.                                          *
 *                                                                              *
 * IfcOpenShell is distributed in the hope that it will be useful,              *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
 * Lesser GNU General Public License for more details.                          *
 *                                                                              *
 * You should have received a copy of the Lesser GNU General Public License     *
 * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
 *                                                                              *
 ********************************************************************************/

/********************************************************************************
 *                                                                              *
 * This file has been generated from IFC2X3_TC1.exp. Do not make modifications  *
 * but instead modify the python script that has been used to generate this.    *
 *                                                                              *
 ********************************************************************************/

#include "../ifcparse/Ifc2x3.h"
#include "../ifcparse/IfcSchema.h"
#include "../ifcparse/IfcException.h"
#include "../ifcparse/IfcFile.h"

#include <map>

const char* const Ifc2x3::Identifier = "IFC2X3";

using namespace IfcParse;

// External definitions
extern declaration* IFC2X3_types[980];


const IfcParse::enumeration_type& Ifc2x3::IfcActionSourceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[4]); }
const IfcParse::enumeration_type& Ifc2x3::IfcActionSourceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[4]); }

Ifc2x3::IfcActionSourceTypeEnum::IfcActionSourceTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcActionSourceTypeEnum::IfcActionSourceTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcActionSourceTypeEnum::IfcActionSourceTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcActionSourceTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcActionSourceTypeEnum::IfcActionSourceTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcActionSourceTypeEnum::Value Ifc2x3::IfcActionSourceTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcActionSourceTypeEnum::Value) Ifc2x3::IfcActionSourceTypeEnum::IfcActionSourceTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcActionSourceTypeEnum::operator Ifc2x3::IfcActionSourceTypeEnum::Value() const {
    return (Ifc2x3::IfcActionSourceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcActionTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[5]); }
const IfcParse::enumeration_type& Ifc2x3::IfcActionTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[5]); }

Ifc2x3::IfcActionTypeEnum::IfcActionTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcActionTypeEnum::IfcActionTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcActionTypeEnum::IfcActionTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcActionTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcActionTypeEnum::IfcActionTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcActionTypeEnum::Value Ifc2x3::IfcActionTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcActionTypeEnum::Value) Ifc2x3::IfcActionTypeEnum::IfcActionTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcActionTypeEnum::operator Ifc2x3::IfcActionTypeEnum::Value() const {
    return (Ifc2x3::IfcActionTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcActuatorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[10]); }
const IfcParse::enumeration_type& Ifc2x3::IfcActuatorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[10]); }

Ifc2x3::IfcActuatorTypeEnum::IfcActuatorTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcActuatorTypeEnum::IfcActuatorTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcActuatorTypeEnum::IfcActuatorTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcActuatorTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcActuatorTypeEnum::IfcActuatorTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcActuatorTypeEnum::Value Ifc2x3::IfcActuatorTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcActuatorTypeEnum::Value) Ifc2x3::IfcActuatorTypeEnum::IfcActuatorTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcActuatorTypeEnum::operator Ifc2x3::IfcActuatorTypeEnum::Value() const {
    return (Ifc2x3::IfcActuatorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcAddressTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[12]); }
const IfcParse::enumeration_type& Ifc2x3::IfcAddressTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[12]); }

Ifc2x3::IfcAddressTypeEnum::IfcAddressTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcAddressTypeEnum::IfcAddressTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcAddressTypeEnum::IfcAddressTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcAddressTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcAddressTypeEnum::IfcAddressTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcAddressTypeEnum::Value Ifc2x3::IfcAddressTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcAddressTypeEnum::Value) Ifc2x3::IfcAddressTypeEnum::IfcAddressTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcAddressTypeEnum::operator Ifc2x3::IfcAddressTypeEnum::Value() const {
    return (Ifc2x3::IfcAddressTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcAheadOrBehind::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[13]); }
const IfcParse::enumeration_type& Ifc2x3::IfcAheadOrBehind::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[13]); }

Ifc2x3::IfcAheadOrBehind::IfcAheadOrBehind(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcAheadOrBehind::IfcAheadOrBehind(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcAheadOrBehind::IfcAheadOrBehind(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcAheadOrBehind::ToString(Value v) {
    return Ifc2x3::IfcAheadOrBehind::IfcAheadOrBehind::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcAheadOrBehind::Value Ifc2x3::IfcAheadOrBehind::FromString(const std::string& s) {
    return (Ifc2x3::IfcAheadOrBehind::Value) Ifc2x3::IfcAheadOrBehind::IfcAheadOrBehind::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcAheadOrBehind::operator Ifc2x3::IfcAheadOrBehind::Value() const {
    return (Ifc2x3::IfcAheadOrBehind::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcAirTerminalBoxTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[15]); }
const IfcParse::enumeration_type& Ifc2x3::IfcAirTerminalBoxTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[15]); }

Ifc2x3::IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcAirTerminalBoxTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcAirTerminalBoxTypeEnum::Value Ifc2x3::IfcAirTerminalBoxTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcAirTerminalBoxTypeEnum::Value) Ifc2x3::IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcAirTerminalBoxTypeEnum::operator Ifc2x3::IfcAirTerminalBoxTypeEnum::Value() const {
    return (Ifc2x3::IfcAirTerminalBoxTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcAirTerminalTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[17]); }
const IfcParse::enumeration_type& Ifc2x3::IfcAirTerminalTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[17]); }

Ifc2x3::IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcAirTerminalTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcAirTerminalTypeEnum::Value Ifc2x3::IfcAirTerminalTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcAirTerminalTypeEnum::Value) Ifc2x3::IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcAirTerminalTypeEnum::operator Ifc2x3::IfcAirTerminalTypeEnum::Value() const {
    return (Ifc2x3::IfcAirTerminalTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[19]); }
const IfcParse::enumeration_type& Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[19]); }

Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::Value Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::Value) Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::operator Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::Value() const {
    return (Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcAlarmTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[21]); }
const IfcParse::enumeration_type& Ifc2x3::IfcAlarmTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[21]); }

Ifc2x3::IfcAlarmTypeEnum::IfcAlarmTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcAlarmTypeEnum::IfcAlarmTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcAlarmTypeEnum::IfcAlarmTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcAlarmTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcAlarmTypeEnum::IfcAlarmTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcAlarmTypeEnum::Value Ifc2x3::IfcAlarmTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcAlarmTypeEnum::Value) Ifc2x3::IfcAlarmTypeEnum::IfcAlarmTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcAlarmTypeEnum::operator Ifc2x3::IfcAlarmTypeEnum::Value() const {
    return (Ifc2x3::IfcAlarmTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcAnalysisModelTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[23]); }
const IfcParse::enumeration_type& Ifc2x3::IfcAnalysisModelTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[23]); }

Ifc2x3::IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcAnalysisModelTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcAnalysisModelTypeEnum::Value Ifc2x3::IfcAnalysisModelTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcAnalysisModelTypeEnum::Value) Ifc2x3::IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcAnalysisModelTypeEnum::operator Ifc2x3::IfcAnalysisModelTypeEnum::Value() const {
    return (Ifc2x3::IfcAnalysisModelTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcAnalysisTheoryTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[24]); }
const IfcParse::enumeration_type& Ifc2x3::IfcAnalysisTheoryTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[24]); }

Ifc2x3::IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcAnalysisTheoryTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcAnalysisTheoryTypeEnum::Value Ifc2x3::IfcAnalysisTheoryTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcAnalysisTheoryTypeEnum::Value) Ifc2x3::IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcAnalysisTheoryTypeEnum::operator Ifc2x3::IfcAnalysisTheoryTypeEnum::Value() const {
    return (Ifc2x3::IfcAnalysisTheoryTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcArithmeticOperatorEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[48]); }
const IfcParse::enumeration_type& Ifc2x3::IfcArithmeticOperatorEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[48]); }

Ifc2x3::IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcArithmeticOperatorEnum::ToString(Value v) {
    return Ifc2x3::IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcArithmeticOperatorEnum::Value Ifc2x3::IfcArithmeticOperatorEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcArithmeticOperatorEnum::Value) Ifc2x3::IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcArithmeticOperatorEnum::operator Ifc2x3::IfcArithmeticOperatorEnum::Value() const {
    return (Ifc2x3::IfcArithmeticOperatorEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcAssemblyPlaceEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[49]); }
const IfcParse::enumeration_type& Ifc2x3::IfcAssemblyPlaceEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[49]); }

Ifc2x3::IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcAssemblyPlaceEnum::ToString(Value v) {
    return Ifc2x3::IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcAssemblyPlaceEnum::Value Ifc2x3::IfcAssemblyPlaceEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcAssemblyPlaceEnum::Value) Ifc2x3::IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcAssemblyPlaceEnum::operator Ifc2x3::IfcAssemblyPlaceEnum::Value() const {
    return (Ifc2x3::IfcAssemblyPlaceEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcBSplineCurveForm::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[81]); }
const IfcParse::enumeration_type& Ifc2x3::IfcBSplineCurveForm::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[81]); }

Ifc2x3::IfcBSplineCurveForm::IfcBSplineCurveForm(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcBSplineCurveForm::IfcBSplineCurveForm(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcBSplineCurveForm::IfcBSplineCurveForm(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcBSplineCurveForm::ToString(Value v) {
    return Ifc2x3::IfcBSplineCurveForm::IfcBSplineCurveForm::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcBSplineCurveForm::Value Ifc2x3::IfcBSplineCurveForm::FromString(const std::string& s) {
    return (Ifc2x3::IfcBSplineCurveForm::Value) Ifc2x3::IfcBSplineCurveForm::IfcBSplineCurveForm::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcBSplineCurveForm::operator Ifc2x3::IfcBSplineCurveForm::Value() const {
    return (Ifc2x3::IfcBSplineCurveForm::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcBeamTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[58]); }
const IfcParse::enumeration_type& Ifc2x3::IfcBeamTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[58]); }

Ifc2x3::IfcBeamTypeEnum::IfcBeamTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcBeamTypeEnum::IfcBeamTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcBeamTypeEnum::IfcBeamTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcBeamTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcBeamTypeEnum::IfcBeamTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcBeamTypeEnum::Value Ifc2x3::IfcBeamTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcBeamTypeEnum::Value) Ifc2x3::IfcBeamTypeEnum::IfcBeamTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcBeamTypeEnum::operator Ifc2x3::IfcBeamTypeEnum::Value() const {
    return (Ifc2x3::IfcBeamTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcBenchmarkEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[59]); }
const IfcParse::enumeration_type& Ifc2x3::IfcBenchmarkEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[59]); }

Ifc2x3::IfcBenchmarkEnum::IfcBenchmarkEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcBenchmarkEnum::IfcBenchmarkEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcBenchmarkEnum::IfcBenchmarkEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcBenchmarkEnum::ToString(Value v) {
    return Ifc2x3::IfcBenchmarkEnum::IfcBenchmarkEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcBenchmarkEnum::Value Ifc2x3::IfcBenchmarkEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcBenchmarkEnum::Value) Ifc2x3::IfcBenchmarkEnum::IfcBenchmarkEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcBenchmarkEnum::operator Ifc2x3::IfcBenchmarkEnum::Value() const {
    return (Ifc2x3::IfcBenchmarkEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcBoilerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[64]); }
const IfcParse::enumeration_type& Ifc2x3::IfcBoilerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[64]); }

Ifc2x3::IfcBoilerTypeEnum::IfcBoilerTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcBoilerTypeEnum::IfcBoilerTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcBoilerTypeEnum::IfcBoilerTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcBoilerTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcBoilerTypeEnum::IfcBoilerTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcBoilerTypeEnum::Value Ifc2x3::IfcBoilerTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcBoilerTypeEnum::Value) Ifc2x3::IfcBoilerTypeEnum::IfcBoilerTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcBoilerTypeEnum::operator Ifc2x3::IfcBoilerTypeEnum::Value() const {
    return (Ifc2x3::IfcBoilerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcBooleanOperator::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[68]); }
const IfcParse::enumeration_type& Ifc2x3::IfcBooleanOperator::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[68]); }

Ifc2x3::IfcBooleanOperator::IfcBooleanOperator(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcBooleanOperator::IfcBooleanOperator(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcBooleanOperator::IfcBooleanOperator(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcBooleanOperator::ToString(Value v) {
    return Ifc2x3::IfcBooleanOperator::IfcBooleanOperator::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcBooleanOperator::Value Ifc2x3::IfcBooleanOperator::FromString(const std::string& s) {
    return (Ifc2x3::IfcBooleanOperator::Value) Ifc2x3::IfcBooleanOperator::IfcBooleanOperator::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcBooleanOperator::operator Ifc2x3::IfcBooleanOperator::Value() const {
    return (Ifc2x3::IfcBooleanOperator::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcBuildingElementProxyTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[88]); }
const IfcParse::enumeration_type& Ifc2x3::IfcBuildingElementProxyTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[88]); }

Ifc2x3::IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcBuildingElementProxyTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcBuildingElementProxyTypeEnum::Value Ifc2x3::IfcBuildingElementProxyTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcBuildingElementProxyTypeEnum::Value) Ifc2x3::IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcBuildingElementProxyTypeEnum::operator Ifc2x3::IfcBuildingElementProxyTypeEnum::Value() const {
    return (Ifc2x3::IfcBuildingElementProxyTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcCableCarrierFittingTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[92]); }
const IfcParse::enumeration_type& Ifc2x3::IfcCableCarrierFittingTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[92]); }

Ifc2x3::IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcCableCarrierFittingTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcCableCarrierFittingTypeEnum::Value Ifc2x3::IfcCableCarrierFittingTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcCableCarrierFittingTypeEnum::Value) Ifc2x3::IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcCableCarrierFittingTypeEnum::operator Ifc2x3::IfcCableCarrierFittingTypeEnum::Value() const {
    return (Ifc2x3::IfcCableCarrierFittingTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcCableCarrierSegmentTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[94]); }
const IfcParse::enumeration_type& Ifc2x3::IfcCableCarrierSegmentTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[94]); }

Ifc2x3::IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcCableCarrierSegmentTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcCableCarrierSegmentTypeEnum::Value Ifc2x3::IfcCableCarrierSegmentTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcCableCarrierSegmentTypeEnum::Value) Ifc2x3::IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcCableCarrierSegmentTypeEnum::operator Ifc2x3::IfcCableCarrierSegmentTypeEnum::Value() const {
    return (Ifc2x3::IfcCableCarrierSegmentTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcCableSegmentTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[96]); }
const IfcParse::enumeration_type& Ifc2x3::IfcCableSegmentTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[96]); }

Ifc2x3::IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcCableSegmentTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcCableSegmentTypeEnum::Value Ifc2x3::IfcCableSegmentTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcCableSegmentTypeEnum::Value) Ifc2x3::IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcCableSegmentTypeEnum::operator Ifc2x3::IfcCableSegmentTypeEnum::Value() const {
    return (Ifc2x3::IfcCableSegmentTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcChangeActionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[106]); }
const IfcParse::enumeration_type& Ifc2x3::IfcChangeActionEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[106]); }

Ifc2x3::IfcChangeActionEnum::IfcChangeActionEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcChangeActionEnum::IfcChangeActionEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcChangeActionEnum::IfcChangeActionEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcChangeActionEnum::ToString(Value v) {
    return Ifc2x3::IfcChangeActionEnum::IfcChangeActionEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcChangeActionEnum::Value Ifc2x3::IfcChangeActionEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcChangeActionEnum::Value) Ifc2x3::IfcChangeActionEnum::IfcChangeActionEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcChangeActionEnum::operator Ifc2x3::IfcChangeActionEnum::Value() const {
    return (Ifc2x3::IfcChangeActionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcChillerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[109]); }
const IfcParse::enumeration_type& Ifc2x3::IfcChillerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[109]); }

Ifc2x3::IfcChillerTypeEnum::IfcChillerTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcChillerTypeEnum::IfcChillerTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcChillerTypeEnum::IfcChillerTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcChillerTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcChillerTypeEnum::IfcChillerTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcChillerTypeEnum::Value Ifc2x3::IfcChillerTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcChillerTypeEnum::Value) Ifc2x3::IfcChillerTypeEnum::IfcChillerTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcChillerTypeEnum::operator Ifc2x3::IfcChillerTypeEnum::Value() const {
    return (Ifc2x3::IfcChillerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcCoilTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[122]); }
const IfcParse::enumeration_type& Ifc2x3::IfcCoilTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[122]); }

Ifc2x3::IfcCoilTypeEnum::IfcCoilTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcCoilTypeEnum::IfcCoilTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcCoilTypeEnum::IfcCoilTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcCoilTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcCoilTypeEnum::IfcCoilTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcCoilTypeEnum::Value Ifc2x3::IfcCoilTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcCoilTypeEnum::Value) Ifc2x3::IfcCoilTypeEnum::IfcCoilTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcCoilTypeEnum::operator Ifc2x3::IfcCoilTypeEnum::Value() const {
    return (Ifc2x3::IfcCoilTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcColumnTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[129]); }
const IfcParse::enumeration_type& Ifc2x3::IfcColumnTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[129]); }

Ifc2x3::IfcColumnTypeEnum::IfcColumnTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcColumnTypeEnum::IfcColumnTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcColumnTypeEnum::IfcColumnTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcColumnTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcColumnTypeEnum::IfcColumnTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcColumnTypeEnum::Value Ifc2x3::IfcColumnTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcColumnTypeEnum::Value) Ifc2x3::IfcColumnTypeEnum::IfcColumnTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcColumnTypeEnum::operator Ifc2x3::IfcColumnTypeEnum::Value() const {
    return (Ifc2x3::IfcColumnTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcCompressorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[137]); }
const IfcParse::enumeration_type& Ifc2x3::IfcCompressorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[137]); }

Ifc2x3::IfcCompressorTypeEnum::IfcCompressorTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcCompressorTypeEnum::IfcCompressorTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcCompressorTypeEnum::IfcCompressorTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcCompressorTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcCompressorTypeEnum::IfcCompressorTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcCompressorTypeEnum::Value Ifc2x3::IfcCompressorTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcCompressorTypeEnum::Value) Ifc2x3::IfcCompressorTypeEnum::IfcCompressorTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcCompressorTypeEnum::operator Ifc2x3::IfcCompressorTypeEnum::Value() const {
    return (Ifc2x3::IfcCompressorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcCondenserTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[139]); }
const IfcParse::enumeration_type& Ifc2x3::IfcCondenserTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[139]); }

Ifc2x3::IfcCondenserTypeEnum::IfcCondenserTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcCondenserTypeEnum::IfcCondenserTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcCondenserTypeEnum::IfcCondenserTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcCondenserTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcCondenserTypeEnum::IfcCondenserTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcCondenserTypeEnum::Value Ifc2x3::IfcCondenserTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcCondenserTypeEnum::Value) Ifc2x3::IfcCondenserTypeEnum::IfcCondenserTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcCondenserTypeEnum::operator Ifc2x3::IfcCondenserTypeEnum::Value() const {
    return (Ifc2x3::IfcCondenserTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcConnectionTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[151]); }
const IfcParse::enumeration_type& Ifc2x3::IfcConnectionTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[151]); }

Ifc2x3::IfcConnectionTypeEnum::IfcConnectionTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcConnectionTypeEnum::IfcConnectionTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcConnectionTypeEnum::IfcConnectionTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcConnectionTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcConnectionTypeEnum::IfcConnectionTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcConnectionTypeEnum::Value Ifc2x3::IfcConnectionTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcConnectionTypeEnum::Value) Ifc2x3::IfcConnectionTypeEnum::IfcConnectionTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcConnectionTypeEnum::operator Ifc2x3::IfcConnectionTypeEnum::Value() const {
    return (Ifc2x3::IfcConnectionTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcConstraintEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[155]); }
const IfcParse::enumeration_type& Ifc2x3::IfcConstraintEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[155]); }

Ifc2x3::IfcConstraintEnum::IfcConstraintEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcConstraintEnum::IfcConstraintEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcConstraintEnum::IfcConstraintEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcConstraintEnum::ToString(Value v) {
    return Ifc2x3::IfcConstraintEnum::IfcConstraintEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcConstraintEnum::Value Ifc2x3::IfcConstraintEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcConstraintEnum::Value) Ifc2x3::IfcConstraintEnum::IfcConstraintEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcConstraintEnum::operator Ifc2x3::IfcConstraintEnum::Value() const {
    return (Ifc2x3::IfcConstraintEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcControllerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[165]); }
const IfcParse::enumeration_type& Ifc2x3::IfcControllerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[165]); }

Ifc2x3::IfcControllerTypeEnum::IfcControllerTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcControllerTypeEnum::IfcControllerTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcControllerTypeEnum::IfcControllerTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcControllerTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcControllerTypeEnum::IfcControllerTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcControllerTypeEnum::Value Ifc2x3::IfcControllerTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcControllerTypeEnum::Value) Ifc2x3::IfcControllerTypeEnum::IfcControllerTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcControllerTypeEnum::operator Ifc2x3::IfcControllerTypeEnum::Value() const {
    return (Ifc2x3::IfcControllerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcCooledBeamTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[168]); }
const IfcParse::enumeration_type& Ifc2x3::IfcCooledBeamTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[168]); }

Ifc2x3::IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcCooledBeamTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcCooledBeamTypeEnum::Value Ifc2x3::IfcCooledBeamTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcCooledBeamTypeEnum::Value) Ifc2x3::IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcCooledBeamTypeEnum::operator Ifc2x3::IfcCooledBeamTypeEnum::Value() const {
    return (Ifc2x3::IfcCooledBeamTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcCoolingTowerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[170]); }
const IfcParse::enumeration_type& Ifc2x3::IfcCoolingTowerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[170]); }

Ifc2x3::IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcCoolingTowerTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcCoolingTowerTypeEnum::Value Ifc2x3::IfcCoolingTowerTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcCoolingTowerTypeEnum::Value) Ifc2x3::IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcCoolingTowerTypeEnum::operator Ifc2x3::IfcCoolingTowerTypeEnum::Value() const {
    return (Ifc2x3::IfcCoolingTowerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcCostScheduleTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[174]); }
const IfcParse::enumeration_type& Ifc2x3::IfcCostScheduleTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[174]); }

Ifc2x3::IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcCostScheduleTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcCostScheduleTypeEnum::Value Ifc2x3::IfcCostScheduleTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcCostScheduleTypeEnum::Value) Ifc2x3::IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcCostScheduleTypeEnum::operator Ifc2x3::IfcCostScheduleTypeEnum::Value() const {
    return (Ifc2x3::IfcCostScheduleTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcCoveringTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[179]); }
const IfcParse::enumeration_type& Ifc2x3::IfcCoveringTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[179]); }

Ifc2x3::IfcCoveringTypeEnum::IfcCoveringTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcCoveringTypeEnum::IfcCoveringTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcCoveringTypeEnum::IfcCoveringTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcCoveringTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcCoveringTypeEnum::IfcCoveringTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcCoveringTypeEnum::Value Ifc2x3::IfcCoveringTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcCoveringTypeEnum::Value) Ifc2x3::IfcCoveringTypeEnum::IfcCoveringTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcCoveringTypeEnum::operator Ifc2x3::IfcCoveringTypeEnum::Value() const {
    return (Ifc2x3::IfcCoveringTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcCurrencyEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[187]); }
const IfcParse::enumeration_type& Ifc2x3::IfcCurrencyEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[187]); }

Ifc2x3::IfcCurrencyEnum::IfcCurrencyEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcCurrencyEnum::IfcCurrencyEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcCurrencyEnum::IfcCurrencyEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcCurrencyEnum::ToString(Value v) {
    return Ifc2x3::IfcCurrencyEnum::IfcCurrencyEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcCurrencyEnum::Value Ifc2x3::IfcCurrencyEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcCurrencyEnum::Value) Ifc2x3::IfcCurrencyEnum::IfcCurrencyEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcCurrencyEnum::operator Ifc2x3::IfcCurrencyEnum::Value() const {
    return (Ifc2x3::IfcCurrencyEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcCurtainWallTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[191]); }
const IfcParse::enumeration_type& Ifc2x3::IfcCurtainWallTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[191]); }

Ifc2x3::IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcCurtainWallTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcCurtainWallTypeEnum::Value Ifc2x3::IfcCurtainWallTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcCurtainWallTypeEnum::Value) Ifc2x3::IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcCurtainWallTypeEnum::operator Ifc2x3::IfcCurtainWallTypeEnum::Value() const {
    return (Ifc2x3::IfcCurtainWallTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcDamperTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[203]); }
const IfcParse::enumeration_type& Ifc2x3::IfcDamperTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[203]); }

Ifc2x3::IfcDamperTypeEnum::IfcDamperTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcDamperTypeEnum::IfcDamperTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcDamperTypeEnum::IfcDamperTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcDamperTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcDamperTypeEnum::IfcDamperTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcDamperTypeEnum::Value Ifc2x3::IfcDamperTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcDamperTypeEnum::Value) Ifc2x3::IfcDamperTypeEnum::IfcDamperTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcDamperTypeEnum::operator Ifc2x3::IfcDamperTypeEnum::Value() const {
    return (Ifc2x3::IfcDamperTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcDataOriginEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[204]); }
const IfcParse::enumeration_type& Ifc2x3::IfcDataOriginEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[204]); }

Ifc2x3::IfcDataOriginEnum::IfcDataOriginEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcDataOriginEnum::IfcDataOriginEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcDataOriginEnum::IfcDataOriginEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcDataOriginEnum::ToString(Value v) {
    return Ifc2x3::IfcDataOriginEnum::IfcDataOriginEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcDataOriginEnum::Value Ifc2x3::IfcDataOriginEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcDataOriginEnum::Value) Ifc2x3::IfcDataOriginEnum::IfcDataOriginEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcDataOriginEnum::operator Ifc2x3::IfcDataOriginEnum::Value() const {
    return (Ifc2x3::IfcDataOriginEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcDerivedUnitEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[215]); }
const IfcParse::enumeration_type& Ifc2x3::IfcDerivedUnitEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[215]); }

Ifc2x3::IfcDerivedUnitEnum::IfcDerivedUnitEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcDerivedUnitEnum::IfcDerivedUnitEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcDerivedUnitEnum::IfcDerivedUnitEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcDerivedUnitEnum::ToString(Value v) {
    return Ifc2x3::IfcDerivedUnitEnum::IfcDerivedUnitEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcDerivedUnitEnum::Value Ifc2x3::IfcDerivedUnitEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcDerivedUnitEnum::Value) Ifc2x3::IfcDerivedUnitEnum::IfcDerivedUnitEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcDerivedUnitEnum::operator Ifc2x3::IfcDerivedUnitEnum::Value() const {
    return (Ifc2x3::IfcDerivedUnitEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcDimensionExtentUsage::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[224]); }
const IfcParse::enumeration_type& Ifc2x3::IfcDimensionExtentUsage::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[224]); }

Ifc2x3::IfcDimensionExtentUsage::IfcDimensionExtentUsage(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcDimensionExtentUsage::IfcDimensionExtentUsage(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcDimensionExtentUsage::IfcDimensionExtentUsage(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcDimensionExtentUsage::ToString(Value v) {
    return Ifc2x3::IfcDimensionExtentUsage::IfcDimensionExtentUsage::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcDimensionExtentUsage::Value Ifc2x3::IfcDimensionExtentUsage::FromString(const std::string& s) {
    return (Ifc2x3::IfcDimensionExtentUsage::Value) Ifc2x3::IfcDimensionExtentUsage::IfcDimensionExtentUsage::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcDimensionExtentUsage::operator Ifc2x3::IfcDimensionExtentUsage::Value() const {
    return (Ifc2x3::IfcDimensionExtentUsage::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcDirectionSenseEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[227]); }
const IfcParse::enumeration_type& Ifc2x3::IfcDirectionSenseEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[227]); }

Ifc2x3::IfcDirectionSenseEnum::IfcDirectionSenseEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcDirectionSenseEnum::IfcDirectionSenseEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcDirectionSenseEnum::IfcDirectionSenseEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcDirectionSenseEnum::ToString(Value v) {
    return Ifc2x3::IfcDirectionSenseEnum::IfcDirectionSenseEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcDirectionSenseEnum::Value Ifc2x3::IfcDirectionSenseEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcDirectionSenseEnum::Value) Ifc2x3::IfcDirectionSenseEnum::IfcDirectionSenseEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcDirectionSenseEnum::operator Ifc2x3::IfcDirectionSenseEnum::Value() const {
    return (Ifc2x3::IfcDirectionSenseEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcDistributionChamberElementTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[232]); }
const IfcParse::enumeration_type& Ifc2x3::IfcDistributionChamberElementTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[232]); }

Ifc2x3::IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcDistributionChamberElementTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcDistributionChamberElementTypeEnum::Value Ifc2x3::IfcDistributionChamberElementTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcDistributionChamberElementTypeEnum::Value) Ifc2x3::IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcDistributionChamberElementTypeEnum::operator Ifc2x3::IfcDistributionChamberElementTypeEnum::Value() const {
    return (Ifc2x3::IfcDistributionChamberElementTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcDocumentConfidentialityEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[240]); }
const IfcParse::enumeration_type& Ifc2x3::IfcDocumentConfidentialityEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[240]); }

Ifc2x3::IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcDocumentConfidentialityEnum::ToString(Value v) {
    return Ifc2x3::IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcDocumentConfidentialityEnum::Value Ifc2x3::IfcDocumentConfidentialityEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcDocumentConfidentialityEnum::Value) Ifc2x3::IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcDocumentConfidentialityEnum::operator Ifc2x3::IfcDocumentConfidentialityEnum::Value() const {
    return (Ifc2x3::IfcDocumentConfidentialityEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcDocumentStatusEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[246]); }
const IfcParse::enumeration_type& Ifc2x3::IfcDocumentStatusEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[246]); }

Ifc2x3::IfcDocumentStatusEnum::IfcDocumentStatusEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcDocumentStatusEnum::IfcDocumentStatusEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcDocumentStatusEnum::IfcDocumentStatusEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcDocumentStatusEnum::ToString(Value v) {
    return Ifc2x3::IfcDocumentStatusEnum::IfcDocumentStatusEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcDocumentStatusEnum::Value Ifc2x3::IfcDocumentStatusEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcDocumentStatusEnum::Value) Ifc2x3::IfcDocumentStatusEnum::IfcDocumentStatusEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcDocumentStatusEnum::operator Ifc2x3::IfcDocumentStatusEnum::Value() const {
    return (Ifc2x3::IfcDocumentStatusEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcDoorPanelOperationEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[249]); }
const IfcParse::enumeration_type& Ifc2x3::IfcDoorPanelOperationEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[249]); }

Ifc2x3::IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcDoorPanelOperationEnum::ToString(Value v) {
    return Ifc2x3::IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcDoorPanelOperationEnum::Value Ifc2x3::IfcDoorPanelOperationEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcDoorPanelOperationEnum::Value) Ifc2x3::IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcDoorPanelOperationEnum::operator Ifc2x3::IfcDoorPanelOperationEnum::Value() const {
    return (Ifc2x3::IfcDoorPanelOperationEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcDoorPanelPositionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[250]); }
const IfcParse::enumeration_type& Ifc2x3::IfcDoorPanelPositionEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[250]); }

Ifc2x3::IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcDoorPanelPositionEnum::ToString(Value v) {
    return Ifc2x3::IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcDoorPanelPositionEnum::Value Ifc2x3::IfcDoorPanelPositionEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcDoorPanelPositionEnum::Value) Ifc2x3::IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcDoorPanelPositionEnum::operator Ifc2x3::IfcDoorPanelPositionEnum::Value() const {
    return (Ifc2x3::IfcDoorPanelPositionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcDoorStyleConstructionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[253]); }
const IfcParse::enumeration_type& Ifc2x3::IfcDoorStyleConstructionEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[253]); }

Ifc2x3::IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcDoorStyleConstructionEnum::ToString(Value v) {
    return Ifc2x3::IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcDoorStyleConstructionEnum::Value Ifc2x3::IfcDoorStyleConstructionEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcDoorStyleConstructionEnum::Value) Ifc2x3::IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcDoorStyleConstructionEnum::operator Ifc2x3::IfcDoorStyleConstructionEnum::Value() const {
    return (Ifc2x3::IfcDoorStyleConstructionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcDoorStyleOperationEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[254]); }
const IfcParse::enumeration_type& Ifc2x3::IfcDoorStyleOperationEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[254]); }

Ifc2x3::IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcDoorStyleOperationEnum::ToString(Value v) {
    return Ifc2x3::IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcDoorStyleOperationEnum::Value Ifc2x3::IfcDoorStyleOperationEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcDoorStyleOperationEnum::Value) Ifc2x3::IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcDoorStyleOperationEnum::operator Ifc2x3::IfcDoorStyleOperationEnum::Value() const {
    return (Ifc2x3::IfcDoorStyleOperationEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcDuctFittingTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[263]); }
const IfcParse::enumeration_type& Ifc2x3::IfcDuctFittingTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[263]); }

Ifc2x3::IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcDuctFittingTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcDuctFittingTypeEnum::Value Ifc2x3::IfcDuctFittingTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcDuctFittingTypeEnum::Value) Ifc2x3::IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcDuctFittingTypeEnum::operator Ifc2x3::IfcDuctFittingTypeEnum::Value() const {
    return (Ifc2x3::IfcDuctFittingTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcDuctSegmentTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[265]); }
const IfcParse::enumeration_type& Ifc2x3::IfcDuctSegmentTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[265]); }

Ifc2x3::IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcDuctSegmentTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcDuctSegmentTypeEnum::Value Ifc2x3::IfcDuctSegmentTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcDuctSegmentTypeEnum::Value) Ifc2x3::IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcDuctSegmentTypeEnum::operator Ifc2x3::IfcDuctSegmentTypeEnum::Value() const {
    return (Ifc2x3::IfcDuctSegmentTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcDuctSilencerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[267]); }
const IfcParse::enumeration_type& Ifc2x3::IfcDuctSilencerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[267]); }

Ifc2x3::IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcDuctSilencerTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcDuctSilencerTypeEnum::Value Ifc2x3::IfcDuctSilencerTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcDuctSilencerTypeEnum::Value) Ifc2x3::IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcDuctSilencerTypeEnum::operator Ifc2x3::IfcDuctSilencerTypeEnum::Value() const {
    return (Ifc2x3::IfcDuctSilencerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcElectricApplianceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[277]); }
const IfcParse::enumeration_type& Ifc2x3::IfcElectricApplianceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[277]); }

Ifc2x3::IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcElectricApplianceTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcElectricApplianceTypeEnum::Value Ifc2x3::IfcElectricApplianceTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcElectricApplianceTypeEnum::Value) Ifc2x3::IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcElectricApplianceTypeEnum::operator Ifc2x3::IfcElectricApplianceTypeEnum::Value() const {
    return (Ifc2x3::IfcElectricApplianceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcElectricCurrentEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[281]); }
const IfcParse::enumeration_type& Ifc2x3::IfcElectricCurrentEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[281]); }

Ifc2x3::IfcElectricCurrentEnum::IfcElectricCurrentEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcElectricCurrentEnum::IfcElectricCurrentEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcElectricCurrentEnum::IfcElectricCurrentEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcElectricCurrentEnum::ToString(Value v) {
    return Ifc2x3::IfcElectricCurrentEnum::IfcElectricCurrentEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcElectricCurrentEnum::Value Ifc2x3::IfcElectricCurrentEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcElectricCurrentEnum::Value) Ifc2x3::IfcElectricCurrentEnum::IfcElectricCurrentEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcElectricCurrentEnum::operator Ifc2x3::IfcElectricCurrentEnum::Value() const {
    return (Ifc2x3::IfcElectricCurrentEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcElectricDistributionPointFunctionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[284]); }
const IfcParse::enumeration_type& Ifc2x3::IfcElectricDistributionPointFunctionEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[284]); }

Ifc2x3::IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcElectricDistributionPointFunctionEnum::ToString(Value v) {
    return Ifc2x3::IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcElectricDistributionPointFunctionEnum::Value Ifc2x3::IfcElectricDistributionPointFunctionEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcElectricDistributionPointFunctionEnum::Value) Ifc2x3::IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcElectricDistributionPointFunctionEnum::operator Ifc2x3::IfcElectricDistributionPointFunctionEnum::Value() const {
    return (Ifc2x3::IfcElectricDistributionPointFunctionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[286]); }
const IfcParse::enumeration_type& Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[286]); }

Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::Value Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::Value) Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::operator Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::Value() const {
    return (Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcElectricGeneratorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[288]); }
const IfcParse::enumeration_type& Ifc2x3::IfcElectricGeneratorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[288]); }

Ifc2x3::IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcElectricGeneratorTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcElectricGeneratorTypeEnum::Value Ifc2x3::IfcElectricGeneratorTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcElectricGeneratorTypeEnum::Value) Ifc2x3::IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcElectricGeneratorTypeEnum::operator Ifc2x3::IfcElectricGeneratorTypeEnum::Value() const {
    return (Ifc2x3::IfcElectricGeneratorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcElectricHeaterTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[290]); }
const IfcParse::enumeration_type& Ifc2x3::IfcElectricHeaterTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[290]); }

Ifc2x3::IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcElectricHeaterTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcElectricHeaterTypeEnum::Value Ifc2x3::IfcElectricHeaterTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcElectricHeaterTypeEnum::Value) Ifc2x3::IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcElectricHeaterTypeEnum::operator Ifc2x3::IfcElectricHeaterTypeEnum::Value() const {
    return (Ifc2x3::IfcElectricHeaterTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcElectricMotorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[292]); }
const IfcParse::enumeration_type& Ifc2x3::IfcElectricMotorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[292]); }

Ifc2x3::IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcElectricMotorTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcElectricMotorTypeEnum::Value Ifc2x3::IfcElectricMotorTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcElectricMotorTypeEnum::Value) Ifc2x3::IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcElectricMotorTypeEnum::operator Ifc2x3::IfcElectricMotorTypeEnum::Value() const {
    return (Ifc2x3::IfcElectricMotorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcElectricTimeControlTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[295]); }
const IfcParse::enumeration_type& Ifc2x3::IfcElectricTimeControlTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[295]); }

Ifc2x3::IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcElectricTimeControlTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcElectricTimeControlTypeEnum::Value Ifc2x3::IfcElectricTimeControlTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcElectricTimeControlTypeEnum::Value) Ifc2x3::IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcElectricTimeControlTypeEnum::operator Ifc2x3::IfcElectricTimeControlTypeEnum::Value() const {
    return (Ifc2x3::IfcElectricTimeControlTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcElementAssemblyTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[300]); }
const IfcParse::enumeration_type& Ifc2x3::IfcElementAssemblyTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[300]); }

Ifc2x3::IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcElementAssemblyTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcElementAssemblyTypeEnum::Value Ifc2x3::IfcElementAssemblyTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcElementAssemblyTypeEnum::Value) Ifc2x3::IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcElementAssemblyTypeEnum::operator Ifc2x3::IfcElementAssemblyTypeEnum::Value() const {
    return (Ifc2x3::IfcElementAssemblyTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcElementCompositionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[303]); }
const IfcParse::enumeration_type& Ifc2x3::IfcElementCompositionEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[303]); }

Ifc2x3::IfcElementCompositionEnum::IfcElementCompositionEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcElementCompositionEnum::IfcElementCompositionEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcElementCompositionEnum::IfcElementCompositionEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcElementCompositionEnum::ToString(Value v) {
    return Ifc2x3::IfcElementCompositionEnum::IfcElementCompositionEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcElementCompositionEnum::Value Ifc2x3::IfcElementCompositionEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcElementCompositionEnum::Value) Ifc2x3::IfcElementCompositionEnum::IfcElementCompositionEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcElementCompositionEnum::operator Ifc2x3::IfcElementCompositionEnum::Value() const {
    return (Ifc2x3::IfcElementCompositionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcEnergySequenceEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[312]); }
const IfcParse::enumeration_type& Ifc2x3::IfcEnergySequenceEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[312]); }

Ifc2x3::IfcEnergySequenceEnum::IfcEnergySequenceEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcEnergySequenceEnum::IfcEnergySequenceEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcEnergySequenceEnum::IfcEnergySequenceEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcEnergySequenceEnum::ToString(Value v) {
    return Ifc2x3::IfcEnergySequenceEnum::IfcEnergySequenceEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcEnergySequenceEnum::Value Ifc2x3::IfcEnergySequenceEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcEnergySequenceEnum::Value) Ifc2x3::IfcEnergySequenceEnum::IfcEnergySequenceEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcEnergySequenceEnum::operator Ifc2x3::IfcEnergySequenceEnum::Value() const {
    return (Ifc2x3::IfcEnergySequenceEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcEnvironmentalImpactCategoryEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[313]); }
const IfcParse::enumeration_type& Ifc2x3::IfcEnvironmentalImpactCategoryEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[313]); }

Ifc2x3::IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcEnvironmentalImpactCategoryEnum::ToString(Value v) {
    return Ifc2x3::IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcEnvironmentalImpactCategoryEnum::Value Ifc2x3::IfcEnvironmentalImpactCategoryEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcEnvironmentalImpactCategoryEnum::Value) Ifc2x3::IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcEnvironmentalImpactCategoryEnum::operator Ifc2x3::IfcEnvironmentalImpactCategoryEnum::Value() const {
    return (Ifc2x3::IfcEnvironmentalImpactCategoryEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcEvaporativeCoolerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[318]); }
const IfcParse::enumeration_type& Ifc2x3::IfcEvaporativeCoolerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[318]); }

Ifc2x3::IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcEvaporativeCoolerTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcEvaporativeCoolerTypeEnum::Value Ifc2x3::IfcEvaporativeCoolerTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcEvaporativeCoolerTypeEnum::Value) Ifc2x3::IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcEvaporativeCoolerTypeEnum::operator Ifc2x3::IfcEvaporativeCoolerTypeEnum::Value() const {
    return (Ifc2x3::IfcEvaporativeCoolerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcEvaporatorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[320]); }
const IfcParse::enumeration_type& Ifc2x3::IfcEvaporatorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[320]); }

Ifc2x3::IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcEvaporatorTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcEvaporatorTypeEnum::Value Ifc2x3::IfcEvaporatorTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcEvaporatorTypeEnum::Value) Ifc2x3::IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcEvaporatorTypeEnum::operator Ifc2x3::IfcEvaporatorTypeEnum::Value() const {
    return (Ifc2x3::IfcEvaporatorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcFanTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[337]); }
const IfcParse::enumeration_type& Ifc2x3::IfcFanTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[337]); }

Ifc2x3::IfcFanTypeEnum::IfcFanTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcFanTypeEnum::IfcFanTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcFanTypeEnum::IfcFanTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcFanTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcFanTypeEnum::IfcFanTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcFanTypeEnum::Value Ifc2x3::IfcFanTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcFanTypeEnum::Value) Ifc2x3::IfcFanTypeEnum::IfcFanTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcFanTypeEnum::operator Ifc2x3::IfcFanTypeEnum::Value() const {
    return (Ifc2x3::IfcFanTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcFilterTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[350]); }
const IfcParse::enumeration_type& Ifc2x3::IfcFilterTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[350]); }

Ifc2x3::IfcFilterTypeEnum::IfcFilterTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcFilterTypeEnum::IfcFilterTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcFilterTypeEnum::IfcFilterTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcFilterTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcFilterTypeEnum::IfcFilterTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcFilterTypeEnum::Value Ifc2x3::IfcFilterTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcFilterTypeEnum::Value) Ifc2x3::IfcFilterTypeEnum::IfcFilterTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcFilterTypeEnum::operator Ifc2x3::IfcFilterTypeEnum::Value() const {
    return (Ifc2x3::IfcFilterTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcFireSuppressionTerminalTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[352]); }
const IfcParse::enumeration_type& Ifc2x3::IfcFireSuppressionTerminalTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[352]); }

Ifc2x3::IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcFireSuppressionTerminalTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcFireSuppressionTerminalTypeEnum::Value Ifc2x3::IfcFireSuppressionTerminalTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcFireSuppressionTerminalTypeEnum::Value) Ifc2x3::IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcFireSuppressionTerminalTypeEnum::operator Ifc2x3::IfcFireSuppressionTerminalTypeEnum::Value() const {
    return (Ifc2x3::IfcFireSuppressionTerminalTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcFlowDirectionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[355]); }
const IfcParse::enumeration_type& Ifc2x3::IfcFlowDirectionEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[355]); }

Ifc2x3::IfcFlowDirectionEnum::IfcFlowDirectionEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcFlowDirectionEnum::IfcFlowDirectionEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcFlowDirectionEnum::IfcFlowDirectionEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcFlowDirectionEnum::ToString(Value v) {
    return Ifc2x3::IfcFlowDirectionEnum::IfcFlowDirectionEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcFlowDirectionEnum::Value Ifc2x3::IfcFlowDirectionEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcFlowDirectionEnum::Value) Ifc2x3::IfcFlowDirectionEnum::IfcFlowDirectionEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcFlowDirectionEnum::operator Ifc2x3::IfcFlowDirectionEnum::Value() const {
    return (Ifc2x3::IfcFlowDirectionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcFlowInstrumentTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[359]); }
const IfcParse::enumeration_type& Ifc2x3::IfcFlowInstrumentTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[359]); }

Ifc2x3::IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcFlowInstrumentTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcFlowInstrumentTypeEnum::Value Ifc2x3::IfcFlowInstrumentTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcFlowInstrumentTypeEnum::Value) Ifc2x3::IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcFlowInstrumentTypeEnum::operator Ifc2x3::IfcFlowInstrumentTypeEnum::Value() const {
    return (Ifc2x3::IfcFlowInstrumentTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcFlowMeterTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[361]); }
const IfcParse::enumeration_type& Ifc2x3::IfcFlowMeterTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[361]); }

Ifc2x3::IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcFlowMeterTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcFlowMeterTypeEnum::Value Ifc2x3::IfcFlowMeterTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcFlowMeterTypeEnum::Value) Ifc2x3::IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcFlowMeterTypeEnum::operator Ifc2x3::IfcFlowMeterTypeEnum::Value() const {
    return (Ifc2x3::IfcFlowMeterTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcFootingTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[377]); }
const IfcParse::enumeration_type& Ifc2x3::IfcFootingTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[377]); }

Ifc2x3::IfcFootingTypeEnum::IfcFootingTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcFootingTypeEnum::IfcFootingTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcFootingTypeEnum::IfcFootingTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcFootingTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcFootingTypeEnum::IfcFootingTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcFootingTypeEnum::Value Ifc2x3::IfcFootingTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcFootingTypeEnum::Value) Ifc2x3::IfcFootingTypeEnum::IfcFootingTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcFootingTypeEnum::operator Ifc2x3::IfcFootingTypeEnum::Value() const {
    return (Ifc2x3::IfcFootingTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcGasTerminalTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[386]); }
const IfcParse::enumeration_type& Ifc2x3::IfcGasTerminalTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[386]); }

Ifc2x3::IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcGasTerminalTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcGasTerminalTypeEnum::Value Ifc2x3::IfcGasTerminalTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcGasTerminalTypeEnum::Value) Ifc2x3::IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcGasTerminalTypeEnum::operator Ifc2x3::IfcGasTerminalTypeEnum::Value() const {
    return (Ifc2x3::IfcGasTerminalTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcGeometricProjectionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[390]); }
const IfcParse::enumeration_type& Ifc2x3::IfcGeometricProjectionEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[390]); }

Ifc2x3::IfcGeometricProjectionEnum::IfcGeometricProjectionEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcGeometricProjectionEnum::IfcGeometricProjectionEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcGeometricProjectionEnum::IfcGeometricProjectionEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcGeometricProjectionEnum::ToString(Value v) {
    return Ifc2x3::IfcGeometricProjectionEnum::IfcGeometricProjectionEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcGeometricProjectionEnum::Value Ifc2x3::IfcGeometricProjectionEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcGeometricProjectionEnum::Value) Ifc2x3::IfcGeometricProjectionEnum::IfcGeometricProjectionEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcGeometricProjectionEnum::operator Ifc2x3::IfcGeometricProjectionEnum::Value() const {
    return (Ifc2x3::IfcGeometricProjectionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcGlobalOrLocalEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[397]); }
const IfcParse::enumeration_type& Ifc2x3::IfcGlobalOrLocalEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[397]); }

Ifc2x3::IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcGlobalOrLocalEnum::ToString(Value v) {
    return Ifc2x3::IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcGlobalOrLocalEnum::Value Ifc2x3::IfcGlobalOrLocalEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcGlobalOrLocalEnum::Value) Ifc2x3::IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcGlobalOrLocalEnum::operator Ifc2x3::IfcGlobalOrLocalEnum::Value() const {
    return (Ifc2x3::IfcGlobalOrLocalEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcHeatExchangerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[405]); }
const IfcParse::enumeration_type& Ifc2x3::IfcHeatExchangerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[405]); }

Ifc2x3::IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcHeatExchangerTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcHeatExchangerTypeEnum::Value Ifc2x3::IfcHeatExchangerTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcHeatExchangerTypeEnum::Value) Ifc2x3::IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcHeatExchangerTypeEnum::operator Ifc2x3::IfcHeatExchangerTypeEnum::Value() const {
    return (Ifc2x3::IfcHeatExchangerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcHumidifierTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[410]); }
const IfcParse::enumeration_type& Ifc2x3::IfcHumidifierTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[410]); }

Ifc2x3::IfcHumidifierTypeEnum::IfcHumidifierTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcHumidifierTypeEnum::IfcHumidifierTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcHumidifierTypeEnum::IfcHumidifierTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcHumidifierTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcHumidifierTypeEnum::IfcHumidifierTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcHumidifierTypeEnum::Value Ifc2x3::IfcHumidifierTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcHumidifierTypeEnum::Value) Ifc2x3::IfcHumidifierTypeEnum::IfcHumidifierTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcHumidifierTypeEnum::operator Ifc2x3::IfcHumidifierTypeEnum::Value() const {
    return (Ifc2x3::IfcHumidifierTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcInternalOrExternalEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[418]); }
const IfcParse::enumeration_type& Ifc2x3::IfcInternalOrExternalEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[418]); }

Ifc2x3::IfcInternalOrExternalEnum::IfcInternalOrExternalEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcInternalOrExternalEnum::IfcInternalOrExternalEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcInternalOrExternalEnum::IfcInternalOrExternalEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcInternalOrExternalEnum::ToString(Value v) {
    return Ifc2x3::IfcInternalOrExternalEnum::IfcInternalOrExternalEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcInternalOrExternalEnum::Value Ifc2x3::IfcInternalOrExternalEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcInternalOrExternalEnum::Value) Ifc2x3::IfcInternalOrExternalEnum::IfcInternalOrExternalEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcInternalOrExternalEnum::operator Ifc2x3::IfcInternalOrExternalEnum::Value() const {
    return (Ifc2x3::IfcInternalOrExternalEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcInventoryTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[420]); }
const IfcParse::enumeration_type& Ifc2x3::IfcInventoryTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[420]); }

Ifc2x3::IfcInventoryTypeEnum::IfcInventoryTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcInventoryTypeEnum::IfcInventoryTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcInventoryTypeEnum::IfcInventoryTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcInventoryTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcInventoryTypeEnum::IfcInventoryTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcInventoryTypeEnum::Value Ifc2x3::IfcInventoryTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcInventoryTypeEnum::Value) Ifc2x3::IfcInventoryTypeEnum::IfcInventoryTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcInventoryTypeEnum::operator Ifc2x3::IfcInventoryTypeEnum::Value() const {
    return (Ifc2x3::IfcInventoryTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcJunctionBoxTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[427]); }
const IfcParse::enumeration_type& Ifc2x3::IfcJunctionBoxTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[427]); }

Ifc2x3::IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcJunctionBoxTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcJunctionBoxTypeEnum::Value Ifc2x3::IfcJunctionBoxTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcJunctionBoxTypeEnum::Value) Ifc2x3::IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcJunctionBoxTypeEnum::operator Ifc2x3::IfcJunctionBoxTypeEnum::Value() const {
    return (Ifc2x3::IfcJunctionBoxTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcLampTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[432]); }
const IfcParse::enumeration_type& Ifc2x3::IfcLampTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[432]); }

Ifc2x3::IfcLampTypeEnum::IfcLampTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcLampTypeEnum::IfcLampTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcLampTypeEnum::IfcLampTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcLampTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcLampTypeEnum::IfcLampTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcLampTypeEnum::Value Ifc2x3::IfcLampTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcLampTypeEnum::Value) Ifc2x3::IfcLampTypeEnum::IfcLampTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcLampTypeEnum::operator Ifc2x3::IfcLampTypeEnum::Value() const {
    return (Ifc2x3::IfcLampTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcLayerSetDirectionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[434]); }
const IfcParse::enumeration_type& Ifc2x3::IfcLayerSetDirectionEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[434]); }

Ifc2x3::IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcLayerSetDirectionEnum::ToString(Value v) {
    return Ifc2x3::IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcLayerSetDirectionEnum::Value Ifc2x3::IfcLayerSetDirectionEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcLayerSetDirectionEnum::Value) Ifc2x3::IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcLayerSetDirectionEnum::operator Ifc2x3::IfcLayerSetDirectionEnum::Value() const {
    return (Ifc2x3::IfcLayerSetDirectionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcLightDistributionCurveEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[439]); }
const IfcParse::enumeration_type& Ifc2x3::IfcLightDistributionCurveEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[439]); }

Ifc2x3::IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcLightDistributionCurveEnum::ToString(Value v) {
    return Ifc2x3::IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcLightDistributionCurveEnum::Value Ifc2x3::IfcLightDistributionCurveEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcLightDistributionCurveEnum::Value) Ifc2x3::IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcLightDistributionCurveEnum::operator Ifc2x3::IfcLightDistributionCurveEnum::Value() const {
    return (Ifc2x3::IfcLightDistributionCurveEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcLightEmissionSourceEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[442]); }
const IfcParse::enumeration_type& Ifc2x3::IfcLightEmissionSourceEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[442]); }

Ifc2x3::IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcLightEmissionSourceEnum::ToString(Value v) {
    return Ifc2x3::IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcLightEmissionSourceEnum::Value Ifc2x3::IfcLightEmissionSourceEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcLightEmissionSourceEnum::Value) Ifc2x3::IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcLightEmissionSourceEnum::operator Ifc2x3::IfcLightEmissionSourceEnum::Value() const {
    return (Ifc2x3::IfcLightEmissionSourceEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcLightFixtureTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[444]); }
const IfcParse::enumeration_type& Ifc2x3::IfcLightFixtureTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[444]); }

Ifc2x3::IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcLightFixtureTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcLightFixtureTypeEnum::Value Ifc2x3::IfcLightFixtureTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcLightFixtureTypeEnum::Value) Ifc2x3::IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcLightFixtureTypeEnum::operator Ifc2x3::IfcLightFixtureTypeEnum::Value() const {
    return (Ifc2x3::IfcLightFixtureTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcLoadGroupTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[458]); }
const IfcParse::enumeration_type& Ifc2x3::IfcLoadGroupTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[458]); }

Ifc2x3::IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcLoadGroupTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcLoadGroupTypeEnum::Value Ifc2x3::IfcLoadGroupTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcLoadGroupTypeEnum::Value) Ifc2x3::IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcLoadGroupTypeEnum::operator Ifc2x3::IfcLoadGroupTypeEnum::Value() const {
    return (Ifc2x3::IfcLoadGroupTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcLogicalOperatorEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[462]); }
const IfcParse::enumeration_type& Ifc2x3::IfcLogicalOperatorEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[462]); }

Ifc2x3::IfcLogicalOperatorEnum::IfcLogicalOperatorEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcLogicalOperatorEnum::IfcLogicalOperatorEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcLogicalOperatorEnum::IfcLogicalOperatorEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcLogicalOperatorEnum::ToString(Value v) {
    return Ifc2x3::IfcLogicalOperatorEnum::IfcLogicalOperatorEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcLogicalOperatorEnum::Value Ifc2x3::IfcLogicalOperatorEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcLogicalOperatorEnum::Value) Ifc2x3::IfcLogicalOperatorEnum::IfcLogicalOperatorEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcLogicalOperatorEnum::operator Ifc2x3::IfcLogicalOperatorEnum::Value() const {
    return (Ifc2x3::IfcLogicalOperatorEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcMemberTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[494]); }
const IfcParse::enumeration_type& Ifc2x3::IfcMemberTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[494]); }

Ifc2x3::IfcMemberTypeEnum::IfcMemberTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcMemberTypeEnum::IfcMemberTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcMemberTypeEnum::IfcMemberTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcMemberTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcMemberTypeEnum::IfcMemberTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcMemberTypeEnum::Value Ifc2x3::IfcMemberTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcMemberTypeEnum::Value) Ifc2x3::IfcMemberTypeEnum::IfcMemberTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcMemberTypeEnum::operator Ifc2x3::IfcMemberTypeEnum::Value() const {
    return (Ifc2x3::IfcMemberTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcMotorConnectionTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[509]); }
const IfcParse::enumeration_type& Ifc2x3::IfcMotorConnectionTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[509]); }

Ifc2x3::IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcMotorConnectionTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcMotorConnectionTypeEnum::Value Ifc2x3::IfcMotorConnectionTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcMotorConnectionTypeEnum::Value) Ifc2x3::IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcMotorConnectionTypeEnum::operator Ifc2x3::IfcMotorConnectionTypeEnum::Value() const {
    return (Ifc2x3::IfcMotorConnectionTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcNullStyle::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[513]); }
const IfcParse::enumeration_type& Ifc2x3::IfcNullStyle::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[513]); }

Ifc2x3::IfcNullStyle::IfcNullStyle(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcNullStyle::IfcNullStyle(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcNullStyle::IfcNullStyle(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcNullStyle::ToString(Value v) {
    return Ifc2x3::IfcNullStyle::IfcNullStyle::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcNullStyle::Value Ifc2x3::IfcNullStyle::FromString(const std::string& s) {
    return (Ifc2x3::IfcNullStyle::Value) Ifc2x3::IfcNullStyle::IfcNullStyle::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcNullStyle::operator Ifc2x3::IfcNullStyle::Value() const {
    return (Ifc2x3::IfcNullStyle::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcObjectTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[521]); }
const IfcParse::enumeration_type& Ifc2x3::IfcObjectTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[521]); }

Ifc2x3::IfcObjectTypeEnum::IfcObjectTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcObjectTypeEnum::IfcObjectTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcObjectTypeEnum::IfcObjectTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcObjectTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcObjectTypeEnum::IfcObjectTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcObjectTypeEnum::Value Ifc2x3::IfcObjectTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcObjectTypeEnum::Value) Ifc2x3::IfcObjectTypeEnum::IfcObjectTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcObjectTypeEnum::operator Ifc2x3::IfcObjectTypeEnum::Value() const {
    return (Ifc2x3::IfcObjectTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcObjectiveEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[518]); }
const IfcParse::enumeration_type& Ifc2x3::IfcObjectiveEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[518]); }

Ifc2x3::IfcObjectiveEnum::IfcObjectiveEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcObjectiveEnum::IfcObjectiveEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcObjectiveEnum::IfcObjectiveEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcObjectiveEnum::ToString(Value v) {
    return Ifc2x3::IfcObjectiveEnum::IfcObjectiveEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcObjectiveEnum::Value Ifc2x3::IfcObjectiveEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcObjectiveEnum::Value) Ifc2x3::IfcObjectiveEnum::IfcObjectiveEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcObjectiveEnum::operator Ifc2x3::IfcObjectiveEnum::Value() const {
    return (Ifc2x3::IfcObjectiveEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcOccupantTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[523]); }
const IfcParse::enumeration_type& Ifc2x3::IfcOccupantTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[523]); }

Ifc2x3::IfcOccupantTypeEnum::IfcOccupantTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcOccupantTypeEnum::IfcOccupantTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcOccupantTypeEnum::IfcOccupantTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcOccupantTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcOccupantTypeEnum::IfcOccupantTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcOccupantTypeEnum::Value Ifc2x3::IfcOccupantTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcOccupantTypeEnum::Value) Ifc2x3::IfcOccupantTypeEnum::IfcOccupantTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcOccupantTypeEnum::operator Ifc2x3::IfcOccupantTypeEnum::Value() const {
    return (Ifc2x3::IfcOccupantTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcOutletTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[536]); }
const IfcParse::enumeration_type& Ifc2x3::IfcOutletTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[536]); }

Ifc2x3::IfcOutletTypeEnum::IfcOutletTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcOutletTypeEnum::IfcOutletTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcOutletTypeEnum::IfcOutletTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcOutletTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcOutletTypeEnum::IfcOutletTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcOutletTypeEnum::Value Ifc2x3::IfcOutletTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcOutletTypeEnum::Value) Ifc2x3::IfcOutletTypeEnum::IfcOutletTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcOutletTypeEnum::operator Ifc2x3::IfcOutletTypeEnum::Value() const {
    return (Ifc2x3::IfcOutletTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcPermeableCoveringOperationEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[542]); }
const IfcParse::enumeration_type& Ifc2x3::IfcPermeableCoveringOperationEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[542]); }

Ifc2x3::IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcPermeableCoveringOperationEnum::ToString(Value v) {
    return Ifc2x3::IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcPermeableCoveringOperationEnum::Value Ifc2x3::IfcPermeableCoveringOperationEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcPermeableCoveringOperationEnum::Value) Ifc2x3::IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcPermeableCoveringOperationEnum::operator Ifc2x3::IfcPermeableCoveringOperationEnum::Value() const {
    return (Ifc2x3::IfcPermeableCoveringOperationEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcPhysicalOrVirtualEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[549]); }
const IfcParse::enumeration_type& Ifc2x3::IfcPhysicalOrVirtualEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[549]); }

Ifc2x3::IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcPhysicalOrVirtualEnum::ToString(Value v) {
    return Ifc2x3::IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcPhysicalOrVirtualEnum::Value Ifc2x3::IfcPhysicalOrVirtualEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcPhysicalOrVirtualEnum::Value) Ifc2x3::IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcPhysicalOrVirtualEnum::operator Ifc2x3::IfcPhysicalOrVirtualEnum::Value() const {
    return (Ifc2x3::IfcPhysicalOrVirtualEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcPileConstructionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[553]); }
const IfcParse::enumeration_type& Ifc2x3::IfcPileConstructionEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[553]); }

Ifc2x3::IfcPileConstructionEnum::IfcPileConstructionEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcPileConstructionEnum::IfcPileConstructionEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcPileConstructionEnum::IfcPileConstructionEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcPileConstructionEnum::ToString(Value v) {
    return Ifc2x3::IfcPileConstructionEnum::IfcPileConstructionEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcPileConstructionEnum::Value Ifc2x3::IfcPileConstructionEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcPileConstructionEnum::Value) Ifc2x3::IfcPileConstructionEnum::IfcPileConstructionEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcPileConstructionEnum::operator Ifc2x3::IfcPileConstructionEnum::Value() const {
    return (Ifc2x3::IfcPileConstructionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcPileTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[554]); }
const IfcParse::enumeration_type& Ifc2x3::IfcPileTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[554]); }

Ifc2x3::IfcPileTypeEnum::IfcPileTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcPileTypeEnum::IfcPileTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcPileTypeEnum::IfcPileTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcPileTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcPileTypeEnum::IfcPileTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcPileTypeEnum::Value Ifc2x3::IfcPileTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcPileTypeEnum::Value) Ifc2x3::IfcPileTypeEnum::IfcPileTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcPileTypeEnum::operator Ifc2x3::IfcPileTypeEnum::Value() const {
    return (Ifc2x3::IfcPileTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcPipeFittingTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[556]); }
const IfcParse::enumeration_type& Ifc2x3::IfcPipeFittingTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[556]); }

Ifc2x3::IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcPipeFittingTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcPipeFittingTypeEnum::Value Ifc2x3::IfcPipeFittingTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcPipeFittingTypeEnum::Value) Ifc2x3::IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcPipeFittingTypeEnum::operator Ifc2x3::IfcPipeFittingTypeEnum::Value() const {
    return (Ifc2x3::IfcPipeFittingTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcPipeSegmentTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[558]); }
const IfcParse::enumeration_type& Ifc2x3::IfcPipeSegmentTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[558]); }

Ifc2x3::IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcPipeSegmentTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcPipeSegmentTypeEnum::Value Ifc2x3::IfcPipeSegmentTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcPipeSegmentTypeEnum::Value) Ifc2x3::IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcPipeSegmentTypeEnum::operator Ifc2x3::IfcPipeSegmentTypeEnum::Value() const {
    return (Ifc2x3::IfcPipeSegmentTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcPlateTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[568]); }
const IfcParse::enumeration_type& Ifc2x3::IfcPlateTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[568]); }

Ifc2x3::IfcPlateTypeEnum::IfcPlateTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcPlateTypeEnum::IfcPlateTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcPlateTypeEnum::IfcPlateTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcPlateTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcPlateTypeEnum::IfcPlateTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcPlateTypeEnum::Value Ifc2x3::IfcPlateTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcPlateTypeEnum::Value) Ifc2x3::IfcPlateTypeEnum::IfcPlateTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcPlateTypeEnum::operator Ifc2x3::IfcPlateTypeEnum::Value() const {
    return (Ifc2x3::IfcPlateTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcProcedureTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[598]); }
const IfcParse::enumeration_type& Ifc2x3::IfcProcedureTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[598]); }

Ifc2x3::IfcProcedureTypeEnum::IfcProcedureTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcProcedureTypeEnum::IfcProcedureTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcProcedureTypeEnum::IfcProcedureTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcProcedureTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcProcedureTypeEnum::IfcProcedureTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcProcedureTypeEnum::Value Ifc2x3::IfcProcedureTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcProcedureTypeEnum::Value) Ifc2x3::IfcProcedureTypeEnum::IfcProcedureTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcProcedureTypeEnum::operator Ifc2x3::IfcProcedureTypeEnum::Value() const {
    return (Ifc2x3::IfcProcedureTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcProfileTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[606]); }
const IfcParse::enumeration_type& Ifc2x3::IfcProfileTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[606]); }

Ifc2x3::IfcProfileTypeEnum::IfcProfileTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcProfileTypeEnum::IfcProfileTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcProfileTypeEnum::IfcProfileTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcProfileTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcProfileTypeEnum::IfcProfileTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcProfileTypeEnum::Value Ifc2x3::IfcProfileTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcProfileTypeEnum::Value) Ifc2x3::IfcProfileTypeEnum::IfcProfileTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcProfileTypeEnum::operator Ifc2x3::IfcProfileTypeEnum::Value() const {
    return (Ifc2x3::IfcProfileTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcProjectOrderRecordTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[613]); }
const IfcParse::enumeration_type& Ifc2x3::IfcProjectOrderRecordTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[613]); }

Ifc2x3::IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcProjectOrderRecordTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcProjectOrderRecordTypeEnum::Value Ifc2x3::IfcProjectOrderRecordTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcProjectOrderRecordTypeEnum::Value) Ifc2x3::IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcProjectOrderRecordTypeEnum::operator Ifc2x3::IfcProjectOrderRecordTypeEnum::Value() const {
    return (Ifc2x3::IfcProjectOrderRecordTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcProjectOrderTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[614]); }
const IfcParse::enumeration_type& Ifc2x3::IfcProjectOrderTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[614]); }

Ifc2x3::IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcProjectOrderTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcProjectOrderTypeEnum::Value Ifc2x3::IfcProjectOrderTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcProjectOrderTypeEnum::Value) Ifc2x3::IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcProjectOrderTypeEnum::operator Ifc2x3::IfcProjectOrderTypeEnum::Value() const {
    return (Ifc2x3::IfcProjectOrderTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcProjectedOrTrueLengthEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[608]); }
const IfcParse::enumeration_type& Ifc2x3::IfcProjectedOrTrueLengthEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[608]); }

Ifc2x3::IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcProjectedOrTrueLengthEnum::ToString(Value v) {
    return Ifc2x3::IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcProjectedOrTrueLengthEnum::Value Ifc2x3::IfcProjectedOrTrueLengthEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcProjectedOrTrueLengthEnum::Value) Ifc2x3::IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcProjectedOrTrueLengthEnum::operator Ifc2x3::IfcProjectedOrTrueLengthEnum::Value() const {
    return (Ifc2x3::IfcProjectedOrTrueLengthEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcPropertySourceEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[627]); }
const IfcParse::enumeration_type& Ifc2x3::IfcPropertySourceEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[627]); }

Ifc2x3::IfcPropertySourceEnum::IfcPropertySourceEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcPropertySourceEnum::IfcPropertySourceEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcPropertySourceEnum::IfcPropertySourceEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcPropertySourceEnum::ToString(Value v) {
    return Ifc2x3::IfcPropertySourceEnum::IfcPropertySourceEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcPropertySourceEnum::Value Ifc2x3::IfcPropertySourceEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcPropertySourceEnum::Value) Ifc2x3::IfcPropertySourceEnum::IfcPropertySourceEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcPropertySourceEnum::operator Ifc2x3::IfcPropertySourceEnum::Value() const {
    return (Ifc2x3::IfcPropertySourceEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcProtectiveDeviceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[630]); }
const IfcParse::enumeration_type& Ifc2x3::IfcProtectiveDeviceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[630]); }

Ifc2x3::IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcProtectiveDeviceTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcProtectiveDeviceTypeEnum::Value Ifc2x3::IfcProtectiveDeviceTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcProtectiveDeviceTypeEnum::Value) Ifc2x3::IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcProtectiveDeviceTypeEnum::operator Ifc2x3::IfcProtectiveDeviceTypeEnum::Value() const {
    return (Ifc2x3::IfcProtectiveDeviceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcPumpTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[633]); }
const IfcParse::enumeration_type& Ifc2x3::IfcPumpTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[633]); }

Ifc2x3::IfcPumpTypeEnum::IfcPumpTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcPumpTypeEnum::IfcPumpTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcPumpTypeEnum::IfcPumpTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcPumpTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcPumpTypeEnum::IfcPumpTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcPumpTypeEnum::Value Ifc2x3::IfcPumpTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcPumpTypeEnum::Value) Ifc2x3::IfcPumpTypeEnum::IfcPumpTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcPumpTypeEnum::operator Ifc2x3::IfcPumpTypeEnum::Value() const {
    return (Ifc2x3::IfcPumpTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcRailingTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[644]); }
const IfcParse::enumeration_type& Ifc2x3::IfcRailingTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[644]); }

Ifc2x3::IfcRailingTypeEnum::IfcRailingTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcRailingTypeEnum::IfcRailingTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcRailingTypeEnum::IfcRailingTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcRailingTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcRailingTypeEnum::IfcRailingTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcRailingTypeEnum::Value Ifc2x3::IfcRailingTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcRailingTypeEnum::Value) Ifc2x3::IfcRailingTypeEnum::IfcRailingTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcRailingTypeEnum::operator Ifc2x3::IfcRailingTypeEnum::Value() const {
    return (Ifc2x3::IfcRailingTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcRampFlightTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[648]); }
const IfcParse::enumeration_type& Ifc2x3::IfcRampFlightTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[648]); }

Ifc2x3::IfcRampFlightTypeEnum::IfcRampFlightTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcRampFlightTypeEnum::IfcRampFlightTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcRampFlightTypeEnum::IfcRampFlightTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcRampFlightTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcRampFlightTypeEnum::IfcRampFlightTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcRampFlightTypeEnum::Value Ifc2x3::IfcRampFlightTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcRampFlightTypeEnum::Value) Ifc2x3::IfcRampFlightTypeEnum::IfcRampFlightTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcRampFlightTypeEnum::operator Ifc2x3::IfcRampFlightTypeEnum::Value() const {
    return (Ifc2x3::IfcRampFlightTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcRampTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[649]); }
const IfcParse::enumeration_type& Ifc2x3::IfcRampTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[649]); }

Ifc2x3::IfcRampTypeEnum::IfcRampTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcRampTypeEnum::IfcRampTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcRampTypeEnum::IfcRampTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcRampTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcRampTypeEnum::IfcRampTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcRampTypeEnum::Value Ifc2x3::IfcRampTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcRampTypeEnum::Value) Ifc2x3::IfcRampTypeEnum::IfcRampTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcRampTypeEnum::operator Ifc2x3::IfcRampTypeEnum::Value() const {
    return (Ifc2x3::IfcRampTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcReflectanceMethodEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[658]); }
const IfcParse::enumeration_type& Ifc2x3::IfcReflectanceMethodEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[658]); }

Ifc2x3::IfcReflectanceMethodEnum::IfcReflectanceMethodEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcReflectanceMethodEnum::IfcReflectanceMethodEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcReflectanceMethodEnum::IfcReflectanceMethodEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcReflectanceMethodEnum::ToString(Value v) {
    return Ifc2x3::IfcReflectanceMethodEnum::IfcReflectanceMethodEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcReflectanceMethodEnum::Value Ifc2x3::IfcReflectanceMethodEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcReflectanceMethodEnum::Value) Ifc2x3::IfcReflectanceMethodEnum::IfcReflectanceMethodEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcReflectanceMethodEnum::operator Ifc2x3::IfcReflectanceMethodEnum::Value() const {
    return (Ifc2x3::IfcReflectanceMethodEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcReinforcingBarRoleEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[663]); }
const IfcParse::enumeration_type& Ifc2x3::IfcReinforcingBarRoleEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[663]); }

Ifc2x3::IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcReinforcingBarRoleEnum::ToString(Value v) {
    return Ifc2x3::IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcReinforcingBarRoleEnum::Value Ifc2x3::IfcReinforcingBarRoleEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcReinforcingBarRoleEnum::Value) Ifc2x3::IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcReinforcingBarRoleEnum::operator Ifc2x3::IfcReinforcingBarRoleEnum::Value() const {
    return (Ifc2x3::IfcReinforcingBarRoleEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcReinforcingBarSurfaceEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[664]); }
const IfcParse::enumeration_type& Ifc2x3::IfcReinforcingBarSurfaceEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[664]); }

Ifc2x3::IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcReinforcingBarSurfaceEnum::ToString(Value v) {
    return Ifc2x3::IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcReinforcingBarSurfaceEnum::Value Ifc2x3::IfcReinforcingBarSurfaceEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcReinforcingBarSurfaceEnum::Value) Ifc2x3::IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcReinforcingBarSurfaceEnum::operator Ifc2x3::IfcReinforcingBarSurfaceEnum::Value() const {
    return (Ifc2x3::IfcReinforcingBarSurfaceEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcResourceConsumptionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[723]); }
const IfcParse::enumeration_type& Ifc2x3::IfcResourceConsumptionEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[723]); }

Ifc2x3::IfcResourceConsumptionEnum::IfcResourceConsumptionEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcResourceConsumptionEnum::IfcResourceConsumptionEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcResourceConsumptionEnum::IfcResourceConsumptionEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcResourceConsumptionEnum::ToString(Value v) {
    return Ifc2x3::IfcResourceConsumptionEnum::IfcResourceConsumptionEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcResourceConsumptionEnum::Value Ifc2x3::IfcResourceConsumptionEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcResourceConsumptionEnum::Value) Ifc2x3::IfcResourceConsumptionEnum::IfcResourceConsumptionEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcResourceConsumptionEnum::operator Ifc2x3::IfcResourceConsumptionEnum::Value() const {
    return (Ifc2x3::IfcResourceConsumptionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcRibPlateDirectionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[725]); }
const IfcParse::enumeration_type& Ifc2x3::IfcRibPlateDirectionEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[725]); }

Ifc2x3::IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcRibPlateDirectionEnum::ToString(Value v) {
    return Ifc2x3::IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcRibPlateDirectionEnum::Value Ifc2x3::IfcRibPlateDirectionEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcRibPlateDirectionEnum::Value) Ifc2x3::IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcRibPlateDirectionEnum::operator Ifc2x3::IfcRibPlateDirectionEnum::Value() const {
    return (Ifc2x3::IfcRibPlateDirectionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcRoleEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[729]); }
const IfcParse::enumeration_type& Ifc2x3::IfcRoleEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[729]); }

Ifc2x3::IfcRoleEnum::IfcRoleEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcRoleEnum::IfcRoleEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcRoleEnum::IfcRoleEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcRoleEnum::ToString(Value v) {
    return Ifc2x3::IfcRoleEnum::IfcRoleEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcRoleEnum::Value Ifc2x3::IfcRoleEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcRoleEnum::Value) Ifc2x3::IfcRoleEnum::IfcRoleEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcRoleEnum::operator Ifc2x3::IfcRoleEnum::Value() const {
    return (Ifc2x3::IfcRoleEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcRoofTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[731]); }
const IfcParse::enumeration_type& Ifc2x3::IfcRoofTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[731]); }

Ifc2x3::IfcRoofTypeEnum::IfcRoofTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcRoofTypeEnum::IfcRoofTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcRoofTypeEnum::IfcRoofTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcRoofTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcRoofTypeEnum::IfcRoofTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcRoofTypeEnum::Value Ifc2x3::IfcRoofTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcRoofTypeEnum::Value) Ifc2x3::IfcRoofTypeEnum::IfcRoofTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcRoofTypeEnum::operator Ifc2x3::IfcRoofTypeEnum::Value() const {
    return (Ifc2x3::IfcRoofTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcSIPrefix::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[763]); }
const IfcParse::enumeration_type& Ifc2x3::IfcSIPrefix::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[763]); }

Ifc2x3::IfcSIPrefix::IfcSIPrefix(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcSIPrefix::IfcSIPrefix(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcSIPrefix::IfcSIPrefix(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcSIPrefix::ToString(Value v) {
    return Ifc2x3::IfcSIPrefix::IfcSIPrefix::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcSIPrefix::Value Ifc2x3::IfcSIPrefix::FromString(const std::string& s) {
    return (Ifc2x3::IfcSIPrefix::Value) Ifc2x3::IfcSIPrefix::IfcSIPrefix::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcSIPrefix::operator Ifc2x3::IfcSIPrefix::Value() const {
    return (Ifc2x3::IfcSIPrefix::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcSIUnitName::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[766]); }
const IfcParse::enumeration_type& Ifc2x3::IfcSIUnitName::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[766]); }

Ifc2x3::IfcSIUnitName::IfcSIUnitName(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcSIUnitName::IfcSIUnitName(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcSIUnitName::IfcSIUnitName(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcSIUnitName::ToString(Value v) {
    return Ifc2x3::IfcSIUnitName::IfcSIUnitName::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcSIUnitName::Value Ifc2x3::IfcSIUnitName::FromString(const std::string& s) {
    return (Ifc2x3::IfcSIUnitName::Value) Ifc2x3::IfcSIUnitName::IfcSIUnitName::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcSIUnitName::operator Ifc2x3::IfcSIUnitName::Value() const {
    return (Ifc2x3::IfcSIUnitName::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcSanitaryTerminalTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[739]); }
const IfcParse::enumeration_type& Ifc2x3::IfcSanitaryTerminalTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[739]); }

Ifc2x3::IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcSanitaryTerminalTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcSanitaryTerminalTypeEnum::Value Ifc2x3::IfcSanitaryTerminalTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcSanitaryTerminalTypeEnum::Value) Ifc2x3::IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcSanitaryTerminalTypeEnum::operator Ifc2x3::IfcSanitaryTerminalTypeEnum::Value() const {
    return (Ifc2x3::IfcSanitaryTerminalTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcSectionTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[747]); }
const IfcParse::enumeration_type& Ifc2x3::IfcSectionTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[747]); }

Ifc2x3::IfcSectionTypeEnum::IfcSectionTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcSectionTypeEnum::IfcSectionTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcSectionTypeEnum::IfcSectionTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcSectionTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcSectionTypeEnum::IfcSectionTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcSectionTypeEnum::Value Ifc2x3::IfcSectionTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcSectionTypeEnum::Value) Ifc2x3::IfcSectionTypeEnum::IfcSectionTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcSectionTypeEnum::operator Ifc2x3::IfcSectionTypeEnum::Value() const {
    return (Ifc2x3::IfcSectionTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcSensorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[749]); }
const IfcParse::enumeration_type& Ifc2x3::IfcSensorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[749]); }

Ifc2x3::IfcSensorTypeEnum::IfcSensorTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcSensorTypeEnum::IfcSensorTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcSensorTypeEnum::IfcSensorTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcSensorTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcSensorTypeEnum::IfcSensorTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcSensorTypeEnum::Value Ifc2x3::IfcSensorTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcSensorTypeEnum::Value) Ifc2x3::IfcSensorTypeEnum::IfcSensorTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcSensorTypeEnum::operator Ifc2x3::IfcSensorTypeEnum::Value() const {
    return (Ifc2x3::IfcSensorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcSequenceEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[750]); }
const IfcParse::enumeration_type& Ifc2x3::IfcSequenceEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[750]); }

Ifc2x3::IfcSequenceEnum::IfcSequenceEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcSequenceEnum::IfcSequenceEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcSequenceEnum::IfcSequenceEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcSequenceEnum::ToString(Value v) {
    return Ifc2x3::IfcSequenceEnum::IfcSequenceEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcSequenceEnum::Value Ifc2x3::IfcSequenceEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcSequenceEnum::Value) Ifc2x3::IfcSequenceEnum::IfcSequenceEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcSequenceEnum::operator Ifc2x3::IfcSequenceEnum::Value() const {
    return (Ifc2x3::IfcSequenceEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcServiceLifeFactorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[753]); }
const IfcParse::enumeration_type& Ifc2x3::IfcServiceLifeFactorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[753]); }

Ifc2x3::IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcServiceLifeFactorTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcServiceLifeFactorTypeEnum::Value Ifc2x3::IfcServiceLifeFactorTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcServiceLifeFactorTypeEnum::Value) Ifc2x3::IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcServiceLifeFactorTypeEnum::operator Ifc2x3::IfcServiceLifeFactorTypeEnum::Value() const {
    return (Ifc2x3::IfcServiceLifeFactorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcServiceLifeTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[754]); }
const IfcParse::enumeration_type& Ifc2x3::IfcServiceLifeTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[754]); }

Ifc2x3::IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcServiceLifeTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcServiceLifeTypeEnum::Value Ifc2x3::IfcServiceLifeTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcServiceLifeTypeEnum::Value) Ifc2x3::IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcServiceLifeTypeEnum::operator Ifc2x3::IfcServiceLifeTypeEnum::Value() const {
    return (Ifc2x3::IfcServiceLifeTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcSlabTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[770]); }
const IfcParse::enumeration_type& Ifc2x3::IfcSlabTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[770]); }

Ifc2x3::IfcSlabTypeEnum::IfcSlabTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcSlabTypeEnum::IfcSlabTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcSlabTypeEnum::IfcSlabTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcSlabTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcSlabTypeEnum::IfcSlabTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcSlabTypeEnum::Value Ifc2x3::IfcSlabTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcSlabTypeEnum::Value) Ifc2x3::IfcSlabTypeEnum::IfcSlabTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcSlabTypeEnum::operator Ifc2x3::IfcSlabTypeEnum::Value() const {
    return (Ifc2x3::IfcSlabTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcSoundScaleEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[777]); }
const IfcParse::enumeration_type& Ifc2x3::IfcSoundScaleEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[777]); }

Ifc2x3::IfcSoundScaleEnum::IfcSoundScaleEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcSoundScaleEnum::IfcSoundScaleEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcSoundScaleEnum::IfcSoundScaleEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcSoundScaleEnum::ToString(Value v) {
    return Ifc2x3::IfcSoundScaleEnum::IfcSoundScaleEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcSoundScaleEnum::Value Ifc2x3::IfcSoundScaleEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcSoundScaleEnum::Value) Ifc2x3::IfcSoundScaleEnum::IfcSoundScaleEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcSoundScaleEnum::operator Ifc2x3::IfcSoundScaleEnum::Value() const {
    return (Ifc2x3::IfcSoundScaleEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcSpaceHeaterTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[781]); }
const IfcParse::enumeration_type& Ifc2x3::IfcSpaceHeaterTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[781]); }

Ifc2x3::IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcSpaceHeaterTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcSpaceHeaterTypeEnum::Value Ifc2x3::IfcSpaceHeaterTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcSpaceHeaterTypeEnum::Value) Ifc2x3::IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcSpaceHeaterTypeEnum::operator Ifc2x3::IfcSpaceHeaterTypeEnum::Value() const {
    return (Ifc2x3::IfcSpaceHeaterTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcSpaceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[785]); }
const IfcParse::enumeration_type& Ifc2x3::IfcSpaceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[785]); }

Ifc2x3::IfcSpaceTypeEnum::IfcSpaceTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcSpaceTypeEnum::IfcSpaceTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcSpaceTypeEnum::IfcSpaceTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcSpaceTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcSpaceTypeEnum::IfcSpaceTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcSpaceTypeEnum::Value Ifc2x3::IfcSpaceTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcSpaceTypeEnum::Value) Ifc2x3::IfcSpaceTypeEnum::IfcSpaceTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcSpaceTypeEnum::operator Ifc2x3::IfcSpaceTypeEnum::Value() const {
    return (Ifc2x3::IfcSpaceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcStackTerminalTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[794]); }
const IfcParse::enumeration_type& Ifc2x3::IfcStackTerminalTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[794]); }

Ifc2x3::IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcStackTerminalTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcStackTerminalTypeEnum::Value Ifc2x3::IfcStackTerminalTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcStackTerminalTypeEnum::Value) Ifc2x3::IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcStackTerminalTypeEnum::operator Ifc2x3::IfcStackTerminalTypeEnum::Value() const {
    return (Ifc2x3::IfcStackTerminalTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcStairFlightTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[798]); }
const IfcParse::enumeration_type& Ifc2x3::IfcStairFlightTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[798]); }

Ifc2x3::IfcStairFlightTypeEnum::IfcStairFlightTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcStairFlightTypeEnum::IfcStairFlightTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcStairFlightTypeEnum::IfcStairFlightTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcStairFlightTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcStairFlightTypeEnum::IfcStairFlightTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcStairFlightTypeEnum::Value Ifc2x3::IfcStairFlightTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcStairFlightTypeEnum::Value) Ifc2x3::IfcStairFlightTypeEnum::IfcStairFlightTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcStairFlightTypeEnum::operator Ifc2x3::IfcStairFlightTypeEnum::Value() const {
    return (Ifc2x3::IfcStairFlightTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcStairTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[799]); }
const IfcParse::enumeration_type& Ifc2x3::IfcStairTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[799]); }

Ifc2x3::IfcStairTypeEnum::IfcStairTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcStairTypeEnum::IfcStairTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcStairTypeEnum::IfcStairTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcStairTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcStairTypeEnum::IfcStairTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcStairTypeEnum::Value Ifc2x3::IfcStairTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcStairTypeEnum::Value) Ifc2x3::IfcStairTypeEnum::IfcStairTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcStairTypeEnum::operator Ifc2x3::IfcStairTypeEnum::Value() const {
    return (Ifc2x3::IfcStairTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcStateEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[800]); }
const IfcParse::enumeration_type& Ifc2x3::IfcStateEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[800]); }

Ifc2x3::IfcStateEnum::IfcStateEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcStateEnum::IfcStateEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcStateEnum::IfcStateEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcStateEnum::ToString(Value v) {
    return Ifc2x3::IfcStateEnum::IfcStateEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcStateEnum::Value Ifc2x3::IfcStateEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcStateEnum::Value) Ifc2x3::IfcStateEnum::IfcStateEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcStateEnum::operator Ifc2x3::IfcStateEnum::Value() const {
    return (Ifc2x3::IfcStateEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcStructuralCurveTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[810]); }
const IfcParse::enumeration_type& Ifc2x3::IfcStructuralCurveTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[810]); }

Ifc2x3::IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcStructuralCurveTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcStructuralCurveTypeEnum::Value Ifc2x3::IfcStructuralCurveTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcStructuralCurveTypeEnum::Value) Ifc2x3::IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcStructuralCurveTypeEnum::operator Ifc2x3::IfcStructuralCurveTypeEnum::Value() const {
    return (Ifc2x3::IfcStructuralCurveTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcStructuralSurfaceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[837]); }
const IfcParse::enumeration_type& Ifc2x3::IfcStructuralSurfaceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[837]); }

Ifc2x3::IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcStructuralSurfaceTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcStructuralSurfaceTypeEnum::Value Ifc2x3::IfcStructuralSurfaceTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcStructuralSurfaceTypeEnum::Value) Ifc2x3::IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcStructuralSurfaceTypeEnum::operator Ifc2x3::IfcStructuralSurfaceTypeEnum::Value() const {
    return (Ifc2x3::IfcStructuralSurfaceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcSurfaceSide::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[849]); }
const IfcParse::enumeration_type& Ifc2x3::IfcSurfaceSide::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[849]); }

Ifc2x3::IfcSurfaceSide::IfcSurfaceSide(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcSurfaceSide::IfcSurfaceSide(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcSurfaceSide::IfcSurfaceSide(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcSurfaceSide::ToString(Value v) {
    return Ifc2x3::IfcSurfaceSide::IfcSurfaceSide::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcSurfaceSide::Value Ifc2x3::IfcSurfaceSide::FromString(const std::string& s) {
    return (Ifc2x3::IfcSurfaceSide::Value) Ifc2x3::IfcSurfaceSide::IfcSurfaceSide::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcSurfaceSide::operator Ifc2x3::IfcSurfaceSide::Value() const {
    return (Ifc2x3::IfcSurfaceSide::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcSurfaceTextureEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[858]); }
const IfcParse::enumeration_type& Ifc2x3::IfcSurfaceTextureEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[858]); }

Ifc2x3::IfcSurfaceTextureEnum::IfcSurfaceTextureEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcSurfaceTextureEnum::IfcSurfaceTextureEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcSurfaceTextureEnum::IfcSurfaceTextureEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcSurfaceTextureEnum::ToString(Value v) {
    return Ifc2x3::IfcSurfaceTextureEnum::IfcSurfaceTextureEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcSurfaceTextureEnum::Value Ifc2x3::IfcSurfaceTextureEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcSurfaceTextureEnum::Value) Ifc2x3::IfcSurfaceTextureEnum::IfcSurfaceTextureEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcSurfaceTextureEnum::operator Ifc2x3::IfcSurfaceTextureEnum::Value() const {
    return (Ifc2x3::IfcSurfaceTextureEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcSwitchingDeviceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[863]); }
const IfcParse::enumeration_type& Ifc2x3::IfcSwitchingDeviceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[863]); }

Ifc2x3::IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcSwitchingDeviceTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcSwitchingDeviceTypeEnum::Value Ifc2x3::IfcSwitchingDeviceTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcSwitchingDeviceTypeEnum::Value) Ifc2x3::IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcSwitchingDeviceTypeEnum::operator Ifc2x3::IfcSwitchingDeviceTypeEnum::Value() const {
    return (Ifc2x3::IfcSwitchingDeviceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcTankTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[871]); }
const IfcParse::enumeration_type& Ifc2x3::IfcTankTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[871]); }

Ifc2x3::IfcTankTypeEnum::IfcTankTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcTankTypeEnum::IfcTankTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcTankTypeEnum::IfcTankTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcTankTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcTankTypeEnum::IfcTankTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcTankTypeEnum::Value Ifc2x3::IfcTankTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcTankTypeEnum::Value) Ifc2x3::IfcTankTypeEnum::IfcTankTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcTankTypeEnum::operator Ifc2x3::IfcTankTypeEnum::Value() const {
    return (Ifc2x3::IfcTankTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcTendonTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[877]); }
const IfcParse::enumeration_type& Ifc2x3::IfcTendonTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[877]); }

Ifc2x3::IfcTendonTypeEnum::IfcTendonTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcTendonTypeEnum::IfcTendonTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcTendonTypeEnum::IfcTendonTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcTendonTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcTendonTypeEnum::IfcTendonTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcTendonTypeEnum::Value Ifc2x3::IfcTendonTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcTendonTypeEnum::Value) Ifc2x3::IfcTendonTypeEnum::IfcTendonTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcTendonTypeEnum::operator Ifc2x3::IfcTendonTypeEnum::Value() const {
    return (Ifc2x3::IfcTendonTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcTextPath::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[886]); }
const IfcParse::enumeration_type& Ifc2x3::IfcTextPath::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[886]); }

Ifc2x3::IfcTextPath::IfcTextPath(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcTextPath::IfcTextPath(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcTextPath::IfcTextPath(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcTextPath::ToString(Value v) {
    return Ifc2x3::IfcTextPath::IfcTextPath::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcTextPath::Value Ifc2x3::IfcTextPath::FromString(const std::string& s) {
    return (Ifc2x3::IfcTextPath::Value) Ifc2x3::IfcTextPath::IfcTextPath::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcTextPath::operator Ifc2x3::IfcTextPath::Value() const {
    return (Ifc2x3::IfcTextPath::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcThermalLoadSourceEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[901]); }
const IfcParse::enumeration_type& Ifc2x3::IfcThermalLoadSourceEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[901]); }

Ifc2x3::IfcThermalLoadSourceEnum::IfcThermalLoadSourceEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcThermalLoadSourceEnum::IfcThermalLoadSourceEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcThermalLoadSourceEnum::IfcThermalLoadSourceEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcThermalLoadSourceEnum::ToString(Value v) {
    return Ifc2x3::IfcThermalLoadSourceEnum::IfcThermalLoadSourceEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcThermalLoadSourceEnum::Value Ifc2x3::IfcThermalLoadSourceEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcThermalLoadSourceEnum::Value) Ifc2x3::IfcThermalLoadSourceEnum::IfcThermalLoadSourceEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcThermalLoadSourceEnum::operator Ifc2x3::IfcThermalLoadSourceEnum::Value() const {
    return (Ifc2x3::IfcThermalLoadSourceEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcThermalLoadTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[902]); }
const IfcParse::enumeration_type& Ifc2x3::IfcThermalLoadTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[902]); }

Ifc2x3::IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcThermalLoadTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcThermalLoadTypeEnum::Value Ifc2x3::IfcThermalLoadTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcThermalLoadTypeEnum::Value) Ifc2x3::IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcThermalLoadTypeEnum::operator Ifc2x3::IfcThermalLoadTypeEnum::Value() const {
    return (Ifc2x3::IfcThermalLoadTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcTimeSeriesDataTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[909]); }
const IfcParse::enumeration_type& Ifc2x3::IfcTimeSeriesDataTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[909]); }

Ifc2x3::IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcTimeSeriesDataTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcTimeSeriesDataTypeEnum::Value Ifc2x3::IfcTimeSeriesDataTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcTimeSeriesDataTypeEnum::Value) Ifc2x3::IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcTimeSeriesDataTypeEnum::operator Ifc2x3::IfcTimeSeriesDataTypeEnum::Value() const {
    return (Ifc2x3::IfcTimeSeriesDataTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcTimeSeriesScheduleTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[912]); }
const IfcParse::enumeration_type& Ifc2x3::IfcTimeSeriesScheduleTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[912]); }

Ifc2x3::IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcTimeSeriesScheduleTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcTimeSeriesScheduleTypeEnum::Value Ifc2x3::IfcTimeSeriesScheduleTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcTimeSeriesScheduleTypeEnum::Value) Ifc2x3::IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcTimeSeriesScheduleTypeEnum::operator Ifc2x3::IfcTimeSeriesScheduleTypeEnum::Value() const {
    return (Ifc2x3::IfcTimeSeriesScheduleTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcTransformerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[919]); }
const IfcParse::enumeration_type& Ifc2x3::IfcTransformerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[919]); }

Ifc2x3::IfcTransformerTypeEnum::IfcTransformerTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcTransformerTypeEnum::IfcTransformerTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcTransformerTypeEnum::IfcTransformerTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcTransformerTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcTransformerTypeEnum::IfcTransformerTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcTransformerTypeEnum::Value Ifc2x3::IfcTransformerTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcTransformerTypeEnum::Value) Ifc2x3::IfcTransformerTypeEnum::IfcTransformerTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcTransformerTypeEnum::operator Ifc2x3::IfcTransformerTypeEnum::Value() const {
    return (Ifc2x3::IfcTransformerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcTransitionCode::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[920]); }
const IfcParse::enumeration_type& Ifc2x3::IfcTransitionCode::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[920]); }

Ifc2x3::IfcTransitionCode::IfcTransitionCode(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcTransitionCode::IfcTransitionCode(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcTransitionCode::IfcTransitionCode(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcTransitionCode::ToString(Value v) {
    return Ifc2x3::IfcTransitionCode::IfcTransitionCode::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcTransitionCode::Value Ifc2x3::IfcTransitionCode::FromString(const std::string& s) {
    return (Ifc2x3::IfcTransitionCode::Value) Ifc2x3::IfcTransitionCode::IfcTransitionCode::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcTransitionCode::operator Ifc2x3::IfcTransitionCode::Value() const {
    return (Ifc2x3::IfcTransitionCode::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcTransportElementTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[923]); }
const IfcParse::enumeration_type& Ifc2x3::IfcTransportElementTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[923]); }

Ifc2x3::IfcTransportElementTypeEnum::IfcTransportElementTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcTransportElementTypeEnum::IfcTransportElementTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcTransportElementTypeEnum::IfcTransportElementTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcTransportElementTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcTransportElementTypeEnum::IfcTransportElementTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcTransportElementTypeEnum::Value Ifc2x3::IfcTransportElementTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcTransportElementTypeEnum::Value) Ifc2x3::IfcTransportElementTypeEnum::IfcTransportElementTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcTransportElementTypeEnum::operator Ifc2x3::IfcTransportElementTypeEnum::Value() const {
    return (Ifc2x3::IfcTransportElementTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcTrimmingPreference::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[926]); }
const IfcParse::enumeration_type& Ifc2x3::IfcTrimmingPreference::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[926]); }

Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcTrimmingPreference::ToString(Value v) {
    return Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcTrimmingPreference::Value Ifc2x3::IfcTrimmingPreference::FromString(const std::string& s) {
    return (Ifc2x3::IfcTrimmingPreference::Value) Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcTrimmingPreference::operator Ifc2x3::IfcTrimmingPreference::Value() const {
    return (Ifc2x3::IfcTrimmingPreference::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcTubeBundleTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[930]); }
const IfcParse::enumeration_type& Ifc2x3::IfcTubeBundleTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[930]); }

Ifc2x3::IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcTubeBundleTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcTubeBundleTypeEnum::Value Ifc2x3::IfcTubeBundleTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcTubeBundleTypeEnum::Value) Ifc2x3::IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcTubeBundleTypeEnum::operator Ifc2x3::IfcTubeBundleTypeEnum::Value() const {
    return (Ifc2x3::IfcTubeBundleTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcUnitEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[938]); }
const IfcParse::enumeration_type& Ifc2x3::IfcUnitEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[938]); }

Ifc2x3::IfcUnitEnum::IfcUnitEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcUnitEnum::IfcUnitEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcUnitEnum::IfcUnitEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcUnitEnum::ToString(Value v) {
    return Ifc2x3::IfcUnitEnum::IfcUnitEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcUnitEnum::Value Ifc2x3::IfcUnitEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcUnitEnum::Value) Ifc2x3::IfcUnitEnum::IfcUnitEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcUnitEnum::operator Ifc2x3::IfcUnitEnum::Value() const {
    return (Ifc2x3::IfcUnitEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcUnitaryEquipmentTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[936]); }
const IfcParse::enumeration_type& Ifc2x3::IfcUnitaryEquipmentTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[936]); }

Ifc2x3::IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcUnitaryEquipmentTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcUnitaryEquipmentTypeEnum::Value Ifc2x3::IfcUnitaryEquipmentTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcUnitaryEquipmentTypeEnum::Value) Ifc2x3::IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcUnitaryEquipmentTypeEnum::operator Ifc2x3::IfcUnitaryEquipmentTypeEnum::Value() const {
    return (Ifc2x3::IfcUnitaryEquipmentTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcValveTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[942]); }
const IfcParse::enumeration_type& Ifc2x3::IfcValveTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[942]); }

Ifc2x3::IfcValveTypeEnum::IfcValveTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcValveTypeEnum::IfcValveTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcValveTypeEnum::IfcValveTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcValveTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcValveTypeEnum::IfcValveTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcValveTypeEnum::Value Ifc2x3::IfcValveTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcValveTypeEnum::Value) Ifc2x3::IfcValveTypeEnum::IfcValveTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcValveTypeEnum::operator Ifc2x3::IfcValveTypeEnum::Value() const {
    return (Ifc2x3::IfcValveTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcVibrationIsolatorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[951]); }
const IfcParse::enumeration_type& Ifc2x3::IfcVibrationIsolatorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[951]); }

Ifc2x3::IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcVibrationIsolatorTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcVibrationIsolatorTypeEnum::Value Ifc2x3::IfcVibrationIsolatorTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcVibrationIsolatorTypeEnum::Value) Ifc2x3::IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcVibrationIsolatorTypeEnum::operator Ifc2x3::IfcVibrationIsolatorTypeEnum::Value() const {
    return (Ifc2x3::IfcVibrationIsolatorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcWallTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[959]); }
const IfcParse::enumeration_type& Ifc2x3::IfcWallTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[959]); }

Ifc2x3::IfcWallTypeEnum::IfcWallTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcWallTypeEnum::IfcWallTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcWallTypeEnum::IfcWallTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcWallTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcWallTypeEnum::IfcWallTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcWallTypeEnum::Value Ifc2x3::IfcWallTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcWallTypeEnum::Value) Ifc2x3::IfcWallTypeEnum::IfcWallTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcWallTypeEnum::operator Ifc2x3::IfcWallTypeEnum::Value() const {
    return (Ifc2x3::IfcWallTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcWasteTerminalTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[963]); }
const IfcParse::enumeration_type& Ifc2x3::IfcWasteTerminalTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[963]); }

Ifc2x3::IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcWasteTerminalTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcWasteTerminalTypeEnum::Value Ifc2x3::IfcWasteTerminalTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcWasteTerminalTypeEnum::Value) Ifc2x3::IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcWasteTerminalTypeEnum::operator Ifc2x3::IfcWasteTerminalTypeEnum::Value() const {
    return (Ifc2x3::IfcWasteTerminalTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcWindowPanelOperationEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[967]); }
const IfcParse::enumeration_type& Ifc2x3::IfcWindowPanelOperationEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[967]); }

Ifc2x3::IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcWindowPanelOperationEnum::ToString(Value v) {
    return Ifc2x3::IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcWindowPanelOperationEnum::Value Ifc2x3::IfcWindowPanelOperationEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcWindowPanelOperationEnum::Value) Ifc2x3::IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcWindowPanelOperationEnum::operator Ifc2x3::IfcWindowPanelOperationEnum::Value() const {
    return (Ifc2x3::IfcWindowPanelOperationEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcWindowPanelPositionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[968]); }
const IfcParse::enumeration_type& Ifc2x3::IfcWindowPanelPositionEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[968]); }

Ifc2x3::IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcWindowPanelPositionEnum::ToString(Value v) {
    return Ifc2x3::IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcWindowPanelPositionEnum::Value Ifc2x3::IfcWindowPanelPositionEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcWindowPanelPositionEnum::Value) Ifc2x3::IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcWindowPanelPositionEnum::operator Ifc2x3::IfcWindowPanelPositionEnum::Value() const {
    return (Ifc2x3::IfcWindowPanelPositionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcWindowStyleConstructionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[971]); }
const IfcParse::enumeration_type& Ifc2x3::IfcWindowStyleConstructionEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[971]); }

Ifc2x3::IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcWindowStyleConstructionEnum::ToString(Value v) {
    return Ifc2x3::IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcWindowStyleConstructionEnum::Value Ifc2x3::IfcWindowStyleConstructionEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcWindowStyleConstructionEnum::Value) Ifc2x3::IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcWindowStyleConstructionEnum::operator Ifc2x3::IfcWindowStyleConstructionEnum::Value() const {
    return (Ifc2x3::IfcWindowStyleConstructionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcWindowStyleOperationEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[972]); }
const IfcParse::enumeration_type& Ifc2x3::IfcWindowStyleOperationEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[972]); }

Ifc2x3::IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcWindowStyleOperationEnum::ToString(Value v) {
    return Ifc2x3::IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcWindowStyleOperationEnum::Value Ifc2x3::IfcWindowStyleOperationEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcWindowStyleOperationEnum::Value) Ifc2x3::IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcWindowStyleOperationEnum::operator Ifc2x3::IfcWindowStyleOperationEnum::Value() const {
    return (Ifc2x3::IfcWindowStyleOperationEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::enumeration_type& Ifc2x3::IfcWorkControlTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC2X3_types[974]); }
const IfcParse::enumeration_type& Ifc2x3::IfcWorkControlTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC2X3_types[974]); }

Ifc2x3::IfcWorkControlTypeEnum::IfcWorkControlTypeEnum(IfcEntityInstanceData&& e)
    : IfcBaseType(std::move(e))
{}

Ifc2x3::IfcWorkControlTypeEnum::IfcWorkControlTypeEnum(Value v) {
    set_attribute_value(0, EnumerationReference(&declaration(), static_cast<size_t>(v)));
}

Ifc2x3::IfcWorkControlTypeEnum::IfcWorkControlTypeEnum(const std::string& v) {
    set_attribute_value(0, EnumerationReference(&declaration(), declaration().lookup_enum_offset(v)));
}

const char* Ifc2x3::IfcWorkControlTypeEnum::ToString(Value v) {
    return Ifc2x3::IfcWorkControlTypeEnum::IfcWorkControlTypeEnum::Class().lookup_enum_value((size_t)v);
}

Ifc2x3::IfcWorkControlTypeEnum::Value Ifc2x3::IfcWorkControlTypeEnum::FromString(const std::string& s) {
    return (Ifc2x3::IfcWorkControlTypeEnum::Value) Ifc2x3::IfcWorkControlTypeEnum::IfcWorkControlTypeEnum::Class().lookup_enum_offset(s);
}

Ifc2x3::IfcWorkControlTypeEnum::operator Ifc2x3::IfcWorkControlTypeEnum::Value() const {
    return (Ifc2x3::IfcWorkControlTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
}

const IfcParse::select_type& Ifc2x3::IfcActorSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[8]); }

const IfcParse::select_type& Ifc2x3::IfcAppliedValueSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[39]); }

const IfcParse::select_type& Ifc2x3::IfcAxis2Placement::Class() { return *((IfcParse::select_type*)IFC2X3_types[53]); }

const IfcParse::select_type& Ifc2x3::IfcBooleanOperand::Class() { return *((IfcParse::select_type*)IFC2X3_types[67]); }

const IfcParse::select_type& Ifc2x3::IfcCharacterStyleSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[107]); }

const IfcParse::select_type& Ifc2x3::IfcClassificationNotationSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[118]); }

const IfcParse::select_type& Ifc2x3::IfcColour::Class() { return *((IfcParse::select_type*)IFC2X3_types[123]); }

const IfcParse::select_type& Ifc2x3::IfcColourOrFactor::Class() { return *((IfcParse::select_type*)IFC2X3_types[124]); }

const IfcParse::select_type& Ifc2x3::IfcConditionCriterionSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[142]); }

const IfcParse::select_type& Ifc2x3::IfcCsgSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[184]); }

const IfcParse::select_type& Ifc2x3::IfcCurveFontOrScaledCurveFontSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[195]); }

const IfcParse::select_type& Ifc2x3::IfcCurveOrEdgeCurve::Class() { return *((IfcParse::select_type*)IFC2X3_types[196]); }

const IfcParse::select_type& Ifc2x3::IfcCurveStyleFontSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[201]); }

const IfcParse::select_type& Ifc2x3::IfcDateTimeSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[206]); }

const IfcParse::select_type& Ifc2x3::IfcDefinedSymbolSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[210]); }

const IfcParse::select_type& Ifc2x3::IfcDerivedMeasureValue::Class() { return *((IfcParse::select_type*)IFC2X3_types[211]); }

const IfcParse::select_type& Ifc2x3::IfcDocumentSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[245]); }

const IfcParse::select_type& Ifc2x3::IfcDraughtingCalloutElement::Class() { return *((IfcParse::select_type*)IFC2X3_types[257]); }

const IfcParse::select_type& Ifc2x3::IfcFillAreaStyleTileShapeSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[346]); }

const IfcParse::select_type& Ifc2x3::IfcFillStyleSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[348]); }

const IfcParse::select_type& Ifc2x3::IfcGeometricSetSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[395]); }

const IfcParse::select_type& Ifc2x3::IfcHatchLineDistanceSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[403]); }

const IfcParse::select_type& Ifc2x3::IfcLayeredItem::Class() { return *((IfcParse::select_type*)IFC2X3_types[433]); }

const IfcParse::select_type& Ifc2x3::IfcLibrarySelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[438]); }

const IfcParse::select_type& Ifc2x3::IfcLightDistributionDataSourceSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[441]); }

const IfcParse::select_type& Ifc2x3::IfcMaterialSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[484]); }

const IfcParse::select_type& Ifc2x3::IfcMeasureValue::Class() { return *((IfcParse::select_type*)IFC2X3_types[485]); }

const IfcParse::select_type& Ifc2x3::IfcMetricValueSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[496]); }

const IfcParse::select_type& Ifc2x3::IfcObjectReferenceSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[520]); }

const IfcParse::select_type& Ifc2x3::IfcOrientationSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[533]); }

const IfcParse::select_type& Ifc2x3::IfcPointOrVertexPoint::Class() { return *((IfcParse::select_type*)IFC2X3_types[572]); }

const IfcParse::select_type& Ifc2x3::IfcPresentationStyleSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[595]); }

const IfcParse::select_type& Ifc2x3::IfcShell::Class() { return *((IfcParse::select_type*)IFC2X3_types[759]); }

const IfcParse::select_type& Ifc2x3::IfcSimpleValue::Class() { return *((IfcParse::select_type*)IFC2X3_types[762]); }

const IfcParse::select_type& Ifc2x3::IfcSizeSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[767]); }

const IfcParse::select_type& Ifc2x3::IfcSpecularHighlightSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[790]); }

const IfcParse::select_type& Ifc2x3::IfcStructuralActivityAssignmentSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[803]); }

const IfcParse::select_type& Ifc2x3::IfcSurfaceOrFaceSurface::Class() { return *((IfcParse::select_type*)IFC2X3_types[848]); }

const IfcParse::select_type& Ifc2x3::IfcSurfaceStyleElementSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[851]); }

const IfcParse::select_type& Ifc2x3::IfcSymbolStyleSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[865]); }

const IfcParse::select_type& Ifc2x3::IfcTextFontSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[883]); }

const IfcParse::select_type& Ifc2x3::IfcTextStyleSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[890]); }

const IfcParse::select_type& Ifc2x3::IfcTrimmingSelect::Class() { return *((IfcParse::select_type*)IFC2X3_types[927]); }

const IfcParse::select_type& Ifc2x3::IfcUnit::Class() { return *((IfcParse::select_type*)IFC2X3_types[934]); }

const IfcParse::select_type& Ifc2x3::IfcValue::Class() { return *((IfcParse::select_type*)IFC2X3_types[940]); }

const IfcParse::select_type& Ifc2x3::IfcVectorOrDirection::Class() { return *((IfcParse::select_type*)IFC2X3_types[945]); }


// Function implementations for IfcAbsorbedDoseMeasure
const IfcParse::type_declaration& Ifc2x3::IfcAbsorbedDoseMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[1]); }
const IfcParse::type_declaration& Ifc2x3::IfcAbsorbedDoseMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[1]); }
Ifc2x3::IfcAbsorbedDoseMeasure::IfcAbsorbedDoseMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcAbsorbedDoseMeasure::IfcAbsorbedDoseMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcAbsorbedDoseMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcAccelerationMeasure
const IfcParse::type_declaration& Ifc2x3::IfcAccelerationMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[2]); }
const IfcParse::type_declaration& Ifc2x3::IfcAccelerationMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[2]); }
Ifc2x3::IfcAccelerationMeasure::IfcAccelerationMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcAccelerationMeasure::IfcAccelerationMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcAccelerationMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcAmountOfSubstanceMeasure
const IfcParse::type_declaration& Ifc2x3::IfcAmountOfSubstanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[22]); }
const IfcParse::type_declaration& Ifc2x3::IfcAmountOfSubstanceMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[22]); }
Ifc2x3::IfcAmountOfSubstanceMeasure::IfcAmountOfSubstanceMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcAmountOfSubstanceMeasure::IfcAmountOfSubstanceMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcAmountOfSubstanceMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcAngularVelocityMeasure
const IfcParse::type_declaration& Ifc2x3::IfcAngularVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[26]); }
const IfcParse::type_declaration& Ifc2x3::IfcAngularVelocityMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[26]); }
Ifc2x3::IfcAngularVelocityMeasure::IfcAngularVelocityMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcAngularVelocityMeasure::IfcAngularVelocityMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcAngularVelocityMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcAreaMeasure
const IfcParse::type_declaration& Ifc2x3::IfcAreaMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[47]); }
const IfcParse::type_declaration& Ifc2x3::IfcAreaMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[47]); }
Ifc2x3::IfcAreaMeasure::IfcAreaMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcAreaMeasure::IfcAreaMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcAreaMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcBoolean
const IfcParse::type_declaration& Ifc2x3::IfcBoolean::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[65]); }
const IfcParse::type_declaration& Ifc2x3::IfcBoolean::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[65]); }
Ifc2x3::IfcBoolean::IfcBoolean(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcBoolean::IfcBoolean(bool v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcBoolean::operator bool() const { return get_attribute_value(0); }

// Function implementations for IfcBoxAlignment
const IfcParse::type_declaration& Ifc2x3::IfcBoxAlignment::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[78]); }
const IfcParse::type_declaration& Ifc2x3::IfcBoxAlignment::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[78]); }
Ifc2x3::IfcBoxAlignment::IfcBoxAlignment(IfcEntityInstanceData&& e) : IfcLabel(std::move(e)) {  }
Ifc2x3::IfcBoxAlignment::IfcBoxAlignment(std::string v) : IfcLabel(v) {  }
Ifc2x3::IfcBoxAlignment::operator std::string() const { return get_attribute_value(0); }

// Function implementations for IfcComplexNumber
const IfcParse::type_declaration& Ifc2x3::IfcComplexNumber::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[130]); }
const IfcParse::type_declaration& Ifc2x3::IfcComplexNumber::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[130]); }
Ifc2x3::IfcComplexNumber::IfcComplexNumber(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcComplexNumber::IfcComplexNumber(std::vector< double > /*[1:2]*/ v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcComplexNumber::operator std::vector< double > /*[1:2]*/() const { return get_attribute_value(0); }

// Function implementations for IfcCompoundPlaneAngleMeasure
const IfcParse::type_declaration& Ifc2x3::IfcCompoundPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[135]); }
const IfcParse::type_declaration& Ifc2x3::IfcCompoundPlaneAngleMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[135]); }
Ifc2x3::IfcCompoundPlaneAngleMeasure::IfcCompoundPlaneAngleMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcCompoundPlaneAngleMeasure::IfcCompoundPlaneAngleMeasure(std::vector< int > /*[3:4]*/ v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcCompoundPlaneAngleMeasure::operator std::vector< int > /*[3:4]*/() const { return get_attribute_value(0); }

// Function implementations for IfcContextDependentMeasure
const IfcParse::type_declaration& Ifc2x3::IfcContextDependentMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[161]); }
const IfcParse::type_declaration& Ifc2x3::IfcContextDependentMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[161]); }
Ifc2x3::IfcContextDependentMeasure::IfcContextDependentMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcContextDependentMeasure::IfcContextDependentMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcContextDependentMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcCountMeasure
const IfcParse::type_declaration& Ifc2x3::IfcCountMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[176]); }
const IfcParse::type_declaration& Ifc2x3::IfcCountMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[176]); }
Ifc2x3::IfcCountMeasure::IfcCountMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcCountMeasure::IfcCountMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcCountMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcCurvatureMeasure
const IfcParse::type_declaration& Ifc2x3::IfcCurvatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[192]); }
const IfcParse::type_declaration& Ifc2x3::IfcCurvatureMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[192]); }
Ifc2x3::IfcCurvatureMeasure::IfcCurvatureMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcCurvatureMeasure::IfcCurvatureMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcCurvatureMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcDayInMonthNumber
const IfcParse::type_declaration& Ifc2x3::IfcDayInMonthNumber::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[207]); }
const IfcParse::type_declaration& Ifc2x3::IfcDayInMonthNumber::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[207]); }
Ifc2x3::IfcDayInMonthNumber::IfcDayInMonthNumber(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcDayInMonthNumber::IfcDayInMonthNumber(int v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcDayInMonthNumber::operator int() const { return get_attribute_value(0); }

// Function implementations for IfcDaylightSavingHour
const IfcParse::type_declaration& Ifc2x3::IfcDaylightSavingHour::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[208]); }
const IfcParse::type_declaration& Ifc2x3::IfcDaylightSavingHour::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[208]); }
Ifc2x3::IfcDaylightSavingHour::IfcDaylightSavingHour(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcDaylightSavingHour::IfcDaylightSavingHour(int v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcDaylightSavingHour::operator int() const { return get_attribute_value(0); }

// Function implementations for IfcDescriptiveMeasure
const IfcParse::type_declaration& Ifc2x3::IfcDescriptiveMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[216]); }
const IfcParse::type_declaration& Ifc2x3::IfcDescriptiveMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[216]); }
Ifc2x3::IfcDescriptiveMeasure::IfcDescriptiveMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcDescriptiveMeasure::IfcDescriptiveMeasure(std::string v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcDescriptiveMeasure::operator std::string() const { return get_attribute_value(0); }

// Function implementations for IfcDimensionCount
const IfcParse::type_declaration& Ifc2x3::IfcDimensionCount::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[220]); }
const IfcParse::type_declaration& Ifc2x3::IfcDimensionCount::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[220]); }
Ifc2x3::IfcDimensionCount::IfcDimensionCount(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcDimensionCount::IfcDimensionCount(int v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcDimensionCount::operator int() const { return get_attribute_value(0); }

// Function implementations for IfcDoseEquivalentMeasure
const IfcParse::type_declaration& Ifc2x3::IfcDoseEquivalentMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[255]); }
const IfcParse::type_declaration& Ifc2x3::IfcDoseEquivalentMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[255]); }
Ifc2x3::IfcDoseEquivalentMeasure::IfcDoseEquivalentMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcDoseEquivalentMeasure::IfcDoseEquivalentMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcDoseEquivalentMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcDynamicViscosityMeasure
const IfcParse::type_declaration& Ifc2x3::IfcDynamicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[268]); }
const IfcParse::type_declaration& Ifc2x3::IfcDynamicViscosityMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[268]); }
Ifc2x3::IfcDynamicViscosityMeasure::IfcDynamicViscosityMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcDynamicViscosityMeasure::IfcDynamicViscosityMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcDynamicViscosityMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcElectricCapacitanceMeasure
const IfcParse::type_declaration& Ifc2x3::IfcElectricCapacitanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[278]); }
const IfcParse::type_declaration& Ifc2x3::IfcElectricCapacitanceMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[278]); }
Ifc2x3::IfcElectricCapacitanceMeasure::IfcElectricCapacitanceMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcElectricCapacitanceMeasure::IfcElectricCapacitanceMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcElectricCapacitanceMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcElectricChargeMeasure
const IfcParse::type_declaration& Ifc2x3::IfcElectricChargeMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[279]); }
const IfcParse::type_declaration& Ifc2x3::IfcElectricChargeMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[279]); }
Ifc2x3::IfcElectricChargeMeasure::IfcElectricChargeMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcElectricChargeMeasure::IfcElectricChargeMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcElectricChargeMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcElectricConductanceMeasure
const IfcParse::type_declaration& Ifc2x3::IfcElectricConductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[280]); }
const IfcParse::type_declaration& Ifc2x3::IfcElectricConductanceMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[280]); }
Ifc2x3::IfcElectricConductanceMeasure::IfcElectricConductanceMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcElectricConductanceMeasure::IfcElectricConductanceMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcElectricConductanceMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcElectricCurrentMeasure
const IfcParse::type_declaration& Ifc2x3::IfcElectricCurrentMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[282]); }
const IfcParse::type_declaration& Ifc2x3::IfcElectricCurrentMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[282]); }
Ifc2x3::IfcElectricCurrentMeasure::IfcElectricCurrentMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcElectricCurrentMeasure::IfcElectricCurrentMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcElectricCurrentMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcElectricResistanceMeasure
const IfcParse::type_declaration& Ifc2x3::IfcElectricResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[293]); }
const IfcParse::type_declaration& Ifc2x3::IfcElectricResistanceMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[293]); }
Ifc2x3::IfcElectricResistanceMeasure::IfcElectricResistanceMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcElectricResistanceMeasure::IfcElectricResistanceMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcElectricResistanceMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcElectricVoltageMeasure
const IfcParse::type_declaration& Ifc2x3::IfcElectricVoltageMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[296]); }
const IfcParse::type_declaration& Ifc2x3::IfcElectricVoltageMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[296]); }
Ifc2x3::IfcElectricVoltageMeasure::IfcElectricVoltageMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcElectricVoltageMeasure::IfcElectricVoltageMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcElectricVoltageMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcEnergyMeasure
const IfcParse::type_declaration& Ifc2x3::IfcEnergyMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[310]); }
const IfcParse::type_declaration& Ifc2x3::IfcEnergyMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[310]); }
Ifc2x3::IfcEnergyMeasure::IfcEnergyMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcEnergyMeasure::IfcEnergyMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcEnergyMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcFontStyle
const IfcParse::type_declaration& Ifc2x3::IfcFontStyle::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[373]); }
const IfcParse::type_declaration& Ifc2x3::IfcFontStyle::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[373]); }
Ifc2x3::IfcFontStyle::IfcFontStyle(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcFontStyle::IfcFontStyle(std::string v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcFontStyle::operator std::string() const { return get_attribute_value(0); }

// Function implementations for IfcFontVariant
const IfcParse::type_declaration& Ifc2x3::IfcFontVariant::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[374]); }
const IfcParse::type_declaration& Ifc2x3::IfcFontVariant::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[374]); }
Ifc2x3::IfcFontVariant::IfcFontVariant(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcFontVariant::IfcFontVariant(std::string v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcFontVariant::operator std::string() const { return get_attribute_value(0); }

// Function implementations for IfcFontWeight
const IfcParse::type_declaration& Ifc2x3::IfcFontWeight::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[375]); }
const IfcParse::type_declaration& Ifc2x3::IfcFontWeight::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[375]); }
Ifc2x3::IfcFontWeight::IfcFontWeight(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcFontWeight::IfcFontWeight(std::string v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcFontWeight::operator std::string() const { return get_attribute_value(0); }

// Function implementations for IfcForceMeasure
const IfcParse::type_declaration& Ifc2x3::IfcForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[378]); }
const IfcParse::type_declaration& Ifc2x3::IfcForceMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[378]); }
Ifc2x3::IfcForceMeasure::IfcForceMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcForceMeasure::IfcForceMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcForceMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcFrequencyMeasure
const IfcParse::type_declaration& Ifc2x3::IfcFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[379]); }
const IfcParse::type_declaration& Ifc2x3::IfcFrequencyMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[379]); }
Ifc2x3::IfcFrequencyMeasure::IfcFrequencyMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcFrequencyMeasure::IfcFrequencyMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcFrequencyMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcGloballyUniqueId
const IfcParse::type_declaration& Ifc2x3::IfcGloballyUniqueId::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[396]); }
const IfcParse::type_declaration& Ifc2x3::IfcGloballyUniqueId::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[396]); }
Ifc2x3::IfcGloballyUniqueId::IfcGloballyUniqueId(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcGloballyUniqueId::IfcGloballyUniqueId(std::string v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcGloballyUniqueId::operator std::string() const { return get_attribute_value(0); }

// Function implementations for IfcHeatFluxDensityMeasure
const IfcParse::type_declaration& Ifc2x3::IfcHeatFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[406]); }
const IfcParse::type_declaration& Ifc2x3::IfcHeatFluxDensityMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[406]); }
Ifc2x3::IfcHeatFluxDensityMeasure::IfcHeatFluxDensityMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcHeatFluxDensityMeasure::IfcHeatFluxDensityMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcHeatFluxDensityMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcHeatingValueMeasure
const IfcParse::type_declaration& Ifc2x3::IfcHeatingValueMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[407]); }
const IfcParse::type_declaration& Ifc2x3::IfcHeatingValueMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[407]); }
Ifc2x3::IfcHeatingValueMeasure::IfcHeatingValueMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcHeatingValueMeasure::IfcHeatingValueMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcHeatingValueMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcHourInDay
const IfcParse::type_declaration& Ifc2x3::IfcHourInDay::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[408]); }
const IfcParse::type_declaration& Ifc2x3::IfcHourInDay::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[408]); }
Ifc2x3::IfcHourInDay::IfcHourInDay(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcHourInDay::IfcHourInDay(int v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcHourInDay::operator int() const { return get_attribute_value(0); }

// Function implementations for IfcIdentifier
const IfcParse::type_declaration& Ifc2x3::IfcIdentifier::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[412]); }
const IfcParse::type_declaration& Ifc2x3::IfcIdentifier::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[412]); }
Ifc2x3::IfcIdentifier::IfcIdentifier(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcIdentifier::IfcIdentifier(std::string v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcIdentifier::operator std::string() const { return get_attribute_value(0); }

// Function implementations for IfcIlluminanceMeasure
const IfcParse::type_declaration& Ifc2x3::IfcIlluminanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[413]); }
const IfcParse::type_declaration& Ifc2x3::IfcIlluminanceMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[413]); }
Ifc2x3::IfcIlluminanceMeasure::IfcIlluminanceMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcIlluminanceMeasure::IfcIlluminanceMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcIlluminanceMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcInductanceMeasure
const IfcParse::type_declaration& Ifc2x3::IfcInductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[415]); }
const IfcParse::type_declaration& Ifc2x3::IfcInductanceMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[415]); }
Ifc2x3::IfcInductanceMeasure::IfcInductanceMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcInductanceMeasure::IfcInductanceMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcInductanceMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcInteger
const IfcParse::type_declaration& Ifc2x3::IfcInteger::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[416]); }
const IfcParse::type_declaration& Ifc2x3::IfcInteger::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[416]); }
Ifc2x3::IfcInteger::IfcInteger(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcInteger::IfcInteger(int v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcInteger::operator int() const { return get_attribute_value(0); }

// Function implementations for IfcIntegerCountRateMeasure
const IfcParse::type_declaration& Ifc2x3::IfcIntegerCountRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[417]); }
const IfcParse::type_declaration& Ifc2x3::IfcIntegerCountRateMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[417]); }
Ifc2x3::IfcIntegerCountRateMeasure::IfcIntegerCountRateMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcIntegerCountRateMeasure::IfcIntegerCountRateMeasure(int v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcIntegerCountRateMeasure::operator int() const { return get_attribute_value(0); }

// Function implementations for IfcIonConcentrationMeasure
const IfcParse::type_declaration& Ifc2x3::IfcIonConcentrationMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[421]); }
const IfcParse::type_declaration& Ifc2x3::IfcIonConcentrationMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[421]); }
Ifc2x3::IfcIonConcentrationMeasure::IfcIonConcentrationMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcIonConcentrationMeasure::IfcIonConcentrationMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcIonConcentrationMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcIsothermalMoistureCapacityMeasure
const IfcParse::type_declaration& Ifc2x3::IfcIsothermalMoistureCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[425]); }
const IfcParse::type_declaration& Ifc2x3::IfcIsothermalMoistureCapacityMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[425]); }
Ifc2x3::IfcIsothermalMoistureCapacityMeasure::IfcIsothermalMoistureCapacityMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcIsothermalMoistureCapacityMeasure::IfcIsothermalMoistureCapacityMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcIsothermalMoistureCapacityMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcKinematicViscosityMeasure
const IfcParse::type_declaration& Ifc2x3::IfcKinematicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[428]); }
const IfcParse::type_declaration& Ifc2x3::IfcKinematicViscosityMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[428]); }
Ifc2x3::IfcKinematicViscosityMeasure::IfcKinematicViscosityMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcKinematicViscosityMeasure::IfcKinematicViscosityMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcKinematicViscosityMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcLabel
const IfcParse::type_declaration& Ifc2x3::IfcLabel::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[429]); }
const IfcParse::type_declaration& Ifc2x3::IfcLabel::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[429]); }
Ifc2x3::IfcLabel::IfcLabel(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcLabel::IfcLabel(std::string v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcLabel::operator std::string() const { return get_attribute_value(0); }

// Function implementations for IfcLengthMeasure
const IfcParse::type_declaration& Ifc2x3::IfcLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[435]); }
const IfcParse::type_declaration& Ifc2x3::IfcLengthMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[435]); }
Ifc2x3::IfcLengthMeasure::IfcLengthMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcLengthMeasure::IfcLengthMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcLengthMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcLinearForceMeasure
const IfcParse::type_declaration& Ifc2x3::IfcLinearForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[454]); }
const IfcParse::type_declaration& Ifc2x3::IfcLinearForceMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[454]); }
Ifc2x3::IfcLinearForceMeasure::IfcLinearForceMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcLinearForceMeasure::IfcLinearForceMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcLinearForceMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcLinearMomentMeasure
const IfcParse::type_declaration& Ifc2x3::IfcLinearMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[455]); }
const IfcParse::type_declaration& Ifc2x3::IfcLinearMomentMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[455]); }
Ifc2x3::IfcLinearMomentMeasure::IfcLinearMomentMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcLinearMomentMeasure::IfcLinearMomentMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcLinearMomentMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcLinearStiffnessMeasure
const IfcParse::type_declaration& Ifc2x3::IfcLinearStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[456]); }
const IfcParse::type_declaration& Ifc2x3::IfcLinearStiffnessMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[456]); }
Ifc2x3::IfcLinearStiffnessMeasure::IfcLinearStiffnessMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcLinearStiffnessMeasure::IfcLinearStiffnessMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcLinearStiffnessMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcLinearVelocityMeasure
const IfcParse::type_declaration& Ifc2x3::IfcLinearVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[457]); }
const IfcParse::type_declaration& Ifc2x3::IfcLinearVelocityMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[457]); }
Ifc2x3::IfcLinearVelocityMeasure::IfcLinearVelocityMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcLinearVelocityMeasure::IfcLinearVelocityMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcLinearVelocityMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcLogical
const IfcParse::type_declaration& Ifc2x3::IfcLogical::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[461]); }
const IfcParse::type_declaration& Ifc2x3::IfcLogical::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[461]); }
Ifc2x3::IfcLogical::IfcLogical(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcLogical::IfcLogical(boost::logic::tribool v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcLogical::operator boost::logic::tribool() const { return get_attribute_value(0); }

// Function implementations for IfcLuminousFluxMeasure
const IfcParse::type_declaration& Ifc2x3::IfcLuminousFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[465]); }
const IfcParse::type_declaration& Ifc2x3::IfcLuminousFluxMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[465]); }
Ifc2x3::IfcLuminousFluxMeasure::IfcLuminousFluxMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcLuminousFluxMeasure::IfcLuminousFluxMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcLuminousFluxMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcLuminousIntensityDistributionMeasure
const IfcParse::type_declaration& Ifc2x3::IfcLuminousIntensityDistributionMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[466]); }
const IfcParse::type_declaration& Ifc2x3::IfcLuminousIntensityDistributionMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[466]); }
Ifc2x3::IfcLuminousIntensityDistributionMeasure::IfcLuminousIntensityDistributionMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcLuminousIntensityDistributionMeasure::IfcLuminousIntensityDistributionMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcLuminousIntensityDistributionMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcLuminousIntensityMeasure
const IfcParse::type_declaration& Ifc2x3::IfcLuminousIntensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[467]); }
const IfcParse::type_declaration& Ifc2x3::IfcLuminousIntensityMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[467]); }
Ifc2x3::IfcLuminousIntensityMeasure::IfcLuminousIntensityMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcLuminousIntensityMeasure::IfcLuminousIntensityMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcLuminousIntensityMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcMagneticFluxDensityMeasure
const IfcParse::type_declaration& Ifc2x3::IfcMagneticFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[468]); }
const IfcParse::type_declaration& Ifc2x3::IfcMagneticFluxDensityMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[468]); }
Ifc2x3::IfcMagneticFluxDensityMeasure::IfcMagneticFluxDensityMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcMagneticFluxDensityMeasure::IfcMagneticFluxDensityMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcMagneticFluxDensityMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcMagneticFluxMeasure
const IfcParse::type_declaration& Ifc2x3::IfcMagneticFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[469]); }
const IfcParse::type_declaration& Ifc2x3::IfcMagneticFluxMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[469]); }
Ifc2x3::IfcMagneticFluxMeasure::IfcMagneticFluxMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcMagneticFluxMeasure::IfcMagneticFluxMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcMagneticFluxMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcMassDensityMeasure
const IfcParse::type_declaration& Ifc2x3::IfcMassDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[472]); }
const IfcParse::type_declaration& Ifc2x3::IfcMassDensityMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[472]); }
Ifc2x3::IfcMassDensityMeasure::IfcMassDensityMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcMassDensityMeasure::IfcMassDensityMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcMassDensityMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcMassFlowRateMeasure
const IfcParse::type_declaration& Ifc2x3::IfcMassFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[473]); }
const IfcParse::type_declaration& Ifc2x3::IfcMassFlowRateMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[473]); }
Ifc2x3::IfcMassFlowRateMeasure::IfcMassFlowRateMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcMassFlowRateMeasure::IfcMassFlowRateMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcMassFlowRateMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcMassMeasure
const IfcParse::type_declaration& Ifc2x3::IfcMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[474]); }
const IfcParse::type_declaration& Ifc2x3::IfcMassMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[474]); }
Ifc2x3::IfcMassMeasure::IfcMassMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcMassMeasure::IfcMassMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcMassMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcMassPerLengthMeasure
const IfcParse::type_declaration& Ifc2x3::IfcMassPerLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[475]); }
const IfcParse::type_declaration& Ifc2x3::IfcMassPerLengthMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[475]); }
Ifc2x3::IfcMassPerLengthMeasure::IfcMassPerLengthMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcMassPerLengthMeasure::IfcMassPerLengthMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcMassPerLengthMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcMinuteInHour
const IfcParse::type_declaration& Ifc2x3::IfcMinuteInHour::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[497]); }
const IfcParse::type_declaration& Ifc2x3::IfcMinuteInHour::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[497]); }
Ifc2x3::IfcMinuteInHour::IfcMinuteInHour(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcMinuteInHour::IfcMinuteInHour(int v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcMinuteInHour::operator int() const { return get_attribute_value(0); }

// Function implementations for IfcModulusOfElasticityMeasure
const IfcParse::type_declaration& Ifc2x3::IfcModulusOfElasticityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[498]); }
const IfcParse::type_declaration& Ifc2x3::IfcModulusOfElasticityMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[498]); }
Ifc2x3::IfcModulusOfElasticityMeasure::IfcModulusOfElasticityMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcModulusOfElasticityMeasure::IfcModulusOfElasticityMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcModulusOfElasticityMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcModulusOfLinearSubgradeReactionMeasure
const IfcParse::type_declaration& Ifc2x3::IfcModulusOfLinearSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[499]); }
const IfcParse::type_declaration& Ifc2x3::IfcModulusOfLinearSubgradeReactionMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[499]); }
Ifc2x3::IfcModulusOfLinearSubgradeReactionMeasure::IfcModulusOfLinearSubgradeReactionMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcModulusOfLinearSubgradeReactionMeasure::IfcModulusOfLinearSubgradeReactionMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcModulusOfLinearSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcModulusOfRotationalSubgradeReactionMeasure
const IfcParse::type_declaration& Ifc2x3::IfcModulusOfRotationalSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[500]); }
const IfcParse::type_declaration& Ifc2x3::IfcModulusOfRotationalSubgradeReactionMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[500]); }
Ifc2x3::IfcModulusOfRotationalSubgradeReactionMeasure::IfcModulusOfRotationalSubgradeReactionMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcModulusOfRotationalSubgradeReactionMeasure::IfcModulusOfRotationalSubgradeReactionMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcModulusOfRotationalSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcModulusOfSubgradeReactionMeasure
const IfcParse::type_declaration& Ifc2x3::IfcModulusOfSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[501]); }
const IfcParse::type_declaration& Ifc2x3::IfcModulusOfSubgradeReactionMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[501]); }
Ifc2x3::IfcModulusOfSubgradeReactionMeasure::IfcModulusOfSubgradeReactionMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcModulusOfSubgradeReactionMeasure::IfcModulusOfSubgradeReactionMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcModulusOfSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcMoistureDiffusivityMeasure
const IfcParse::type_declaration& Ifc2x3::IfcMoistureDiffusivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[502]); }
const IfcParse::type_declaration& Ifc2x3::IfcMoistureDiffusivityMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[502]); }
Ifc2x3::IfcMoistureDiffusivityMeasure::IfcMoistureDiffusivityMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcMoistureDiffusivityMeasure::IfcMoistureDiffusivityMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcMoistureDiffusivityMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcMolecularWeightMeasure
const IfcParse::type_declaration& Ifc2x3::IfcMolecularWeightMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[503]); }
const IfcParse::type_declaration& Ifc2x3::IfcMolecularWeightMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[503]); }
Ifc2x3::IfcMolecularWeightMeasure::IfcMolecularWeightMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcMolecularWeightMeasure::IfcMolecularWeightMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcMolecularWeightMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcMomentOfInertiaMeasure
const IfcParse::type_declaration& Ifc2x3::IfcMomentOfInertiaMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[504]); }
const IfcParse::type_declaration& Ifc2x3::IfcMomentOfInertiaMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[504]); }
Ifc2x3::IfcMomentOfInertiaMeasure::IfcMomentOfInertiaMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcMomentOfInertiaMeasure::IfcMomentOfInertiaMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcMomentOfInertiaMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcMonetaryMeasure
const IfcParse::type_declaration& Ifc2x3::IfcMonetaryMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[505]); }
const IfcParse::type_declaration& Ifc2x3::IfcMonetaryMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[505]); }
Ifc2x3::IfcMonetaryMeasure::IfcMonetaryMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcMonetaryMeasure::IfcMonetaryMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcMonetaryMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcMonthInYearNumber
const IfcParse::type_declaration& Ifc2x3::IfcMonthInYearNumber::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[507]); }
const IfcParse::type_declaration& Ifc2x3::IfcMonthInYearNumber::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[507]); }
Ifc2x3::IfcMonthInYearNumber::IfcMonthInYearNumber(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcMonthInYearNumber::IfcMonthInYearNumber(int v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcMonthInYearNumber::operator int() const { return get_attribute_value(0); }

// Function implementations for IfcNormalisedRatioMeasure
const IfcParse::type_declaration& Ifc2x3::IfcNormalisedRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[512]); }
const IfcParse::type_declaration& Ifc2x3::IfcNormalisedRatioMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[512]); }
Ifc2x3::IfcNormalisedRatioMeasure::IfcNormalisedRatioMeasure(IfcEntityInstanceData&& e) : IfcRatioMeasure(std::move(e)) {  }
Ifc2x3::IfcNormalisedRatioMeasure::IfcNormalisedRatioMeasure(double v) : IfcRatioMeasure(v) {  }
Ifc2x3::IfcNormalisedRatioMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcNumericMeasure
const IfcParse::type_declaration& Ifc2x3::IfcNumericMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[514]); }
const IfcParse::type_declaration& Ifc2x3::IfcNumericMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[514]); }
Ifc2x3::IfcNumericMeasure::IfcNumericMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcNumericMeasure::IfcNumericMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcNumericMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcPHMeasure
const IfcParse::type_declaration& Ifc2x3::IfcPHMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[547]); }
const IfcParse::type_declaration& Ifc2x3::IfcPHMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[547]); }
Ifc2x3::IfcPHMeasure::IfcPHMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcPHMeasure::IfcPHMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcPHMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcParameterValue
const IfcParse::type_declaration& Ifc2x3::IfcParameterValue::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[539]); }
const IfcParse::type_declaration& Ifc2x3::IfcParameterValue::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[539]); }
Ifc2x3::IfcParameterValue::IfcParameterValue(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcParameterValue::IfcParameterValue(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcParameterValue::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcPlanarForceMeasure
const IfcParse::type_declaration& Ifc2x3::IfcPlanarForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[563]); }
const IfcParse::type_declaration& Ifc2x3::IfcPlanarForceMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[563]); }
Ifc2x3::IfcPlanarForceMeasure::IfcPlanarForceMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcPlanarForceMeasure::IfcPlanarForceMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcPlanarForceMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcPlaneAngleMeasure
const IfcParse::type_declaration& Ifc2x3::IfcPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[565]); }
const IfcParse::type_declaration& Ifc2x3::IfcPlaneAngleMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[565]); }
Ifc2x3::IfcPlaneAngleMeasure::IfcPlaneAngleMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcPlaneAngleMeasure::IfcPlaneAngleMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcPlaneAngleMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcPositiveLengthMeasure
const IfcParse::type_declaration& Ifc2x3::IfcPositiveLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[577]); }
const IfcParse::type_declaration& Ifc2x3::IfcPositiveLengthMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[577]); }
Ifc2x3::IfcPositiveLengthMeasure::IfcPositiveLengthMeasure(IfcEntityInstanceData&& e) : IfcLengthMeasure(std::move(e)) {  }
Ifc2x3::IfcPositiveLengthMeasure::IfcPositiveLengthMeasure(double v) : IfcLengthMeasure(v) {  }
Ifc2x3::IfcPositiveLengthMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcPositivePlaneAngleMeasure
const IfcParse::type_declaration& Ifc2x3::IfcPositivePlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[578]); }
const IfcParse::type_declaration& Ifc2x3::IfcPositivePlaneAngleMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[578]); }
Ifc2x3::IfcPositivePlaneAngleMeasure::IfcPositivePlaneAngleMeasure(IfcEntityInstanceData&& e) : IfcPlaneAngleMeasure(std::move(e)) {  }
Ifc2x3::IfcPositivePlaneAngleMeasure::IfcPositivePlaneAngleMeasure(double v) : IfcPlaneAngleMeasure(v) {  }
Ifc2x3::IfcPositivePlaneAngleMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcPositiveRatioMeasure
const IfcParse::type_declaration& Ifc2x3::IfcPositiveRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[579]); }
const IfcParse::type_declaration& Ifc2x3::IfcPositiveRatioMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[579]); }
Ifc2x3::IfcPositiveRatioMeasure::IfcPositiveRatioMeasure(IfcEntityInstanceData&& e) : IfcRatioMeasure(std::move(e)) {  }
Ifc2x3::IfcPositiveRatioMeasure::IfcPositiveRatioMeasure(double v) : IfcRatioMeasure(v) {  }
Ifc2x3::IfcPositiveRatioMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcPowerMeasure
const IfcParse::type_declaration& Ifc2x3::IfcPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[581]); }
const IfcParse::type_declaration& Ifc2x3::IfcPowerMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[581]); }
Ifc2x3::IfcPowerMeasure::IfcPowerMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcPowerMeasure::IfcPowerMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcPowerMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcPresentableText
const IfcParse::type_declaration& Ifc2x3::IfcPresentableText::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[590]); }
const IfcParse::type_declaration& Ifc2x3::IfcPresentableText::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[590]); }
Ifc2x3::IfcPresentableText::IfcPresentableText(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcPresentableText::IfcPresentableText(std::string v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcPresentableText::operator std::string() const { return get_attribute_value(0); }

// Function implementations for IfcPressureMeasure
const IfcParse::type_declaration& Ifc2x3::IfcPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[596]); }
const IfcParse::type_declaration& Ifc2x3::IfcPressureMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[596]); }
Ifc2x3::IfcPressureMeasure::IfcPressureMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcPressureMeasure::IfcPressureMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcPressureMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcRadioActivityMeasure
const IfcParse::type_declaration& Ifc2x3::IfcRadioActivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[640]); }
const IfcParse::type_declaration& Ifc2x3::IfcRadioActivityMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[640]); }
Ifc2x3::IfcRadioActivityMeasure::IfcRadioActivityMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcRadioActivityMeasure::IfcRadioActivityMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcRadioActivityMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcRatioMeasure
const IfcParse::type_declaration& Ifc2x3::IfcRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[650]); }
const IfcParse::type_declaration& Ifc2x3::IfcRatioMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[650]); }
Ifc2x3::IfcRatioMeasure::IfcRatioMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcRatioMeasure::IfcRatioMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcRatioMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcReal
const IfcParse::type_declaration& Ifc2x3::IfcReal::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[652]); }
const IfcParse::type_declaration& Ifc2x3::IfcReal::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[652]); }
Ifc2x3::IfcReal::IfcReal(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcReal::IfcReal(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcReal::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcRotationalFrequencyMeasure
const IfcParse::type_declaration& Ifc2x3::IfcRotationalFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[733]); }
const IfcParse::type_declaration& Ifc2x3::IfcRotationalFrequencyMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[733]); }
Ifc2x3::IfcRotationalFrequencyMeasure::IfcRotationalFrequencyMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcRotationalFrequencyMeasure::IfcRotationalFrequencyMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcRotationalFrequencyMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcRotationalMassMeasure
const IfcParse::type_declaration& Ifc2x3::IfcRotationalMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[734]); }
const IfcParse::type_declaration& Ifc2x3::IfcRotationalMassMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[734]); }
Ifc2x3::IfcRotationalMassMeasure::IfcRotationalMassMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcRotationalMassMeasure::IfcRotationalMassMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcRotationalMassMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcRotationalStiffnessMeasure
const IfcParse::type_declaration& Ifc2x3::IfcRotationalStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[735]); }
const IfcParse::type_declaration& Ifc2x3::IfcRotationalStiffnessMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[735]); }
Ifc2x3::IfcRotationalStiffnessMeasure::IfcRotationalStiffnessMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcRotationalStiffnessMeasure::IfcRotationalStiffnessMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcRotationalStiffnessMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcSecondInMinute
const IfcParse::type_declaration& Ifc2x3::IfcSecondInMinute::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[741]); }
const IfcParse::type_declaration& Ifc2x3::IfcSecondInMinute::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[741]); }
Ifc2x3::IfcSecondInMinute::IfcSecondInMinute(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcSecondInMinute::IfcSecondInMinute(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcSecondInMinute::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcSectionModulusMeasure
const IfcParse::type_declaration& Ifc2x3::IfcSectionModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[744]); }
const IfcParse::type_declaration& Ifc2x3::IfcSectionModulusMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[744]); }
Ifc2x3::IfcSectionModulusMeasure::IfcSectionModulusMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcSectionModulusMeasure::IfcSectionModulusMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcSectionModulusMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcSectionalAreaIntegralMeasure
const IfcParse::type_declaration& Ifc2x3::IfcSectionalAreaIntegralMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[742]); }
const IfcParse::type_declaration& Ifc2x3::IfcSectionalAreaIntegralMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[742]); }
Ifc2x3::IfcSectionalAreaIntegralMeasure::IfcSectionalAreaIntegralMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcSectionalAreaIntegralMeasure::IfcSectionalAreaIntegralMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcSectionalAreaIntegralMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcShearModulusMeasure
const IfcParse::type_declaration& Ifc2x3::IfcShearModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[758]); }
const IfcParse::type_declaration& Ifc2x3::IfcShearModulusMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[758]); }
Ifc2x3::IfcShearModulusMeasure::IfcShearModulusMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcShearModulusMeasure::IfcShearModulusMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcShearModulusMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcSolidAngleMeasure
const IfcParse::type_declaration& Ifc2x3::IfcSolidAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[772]); }
const IfcParse::type_declaration& Ifc2x3::IfcSolidAngleMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[772]); }
Ifc2x3::IfcSolidAngleMeasure::IfcSolidAngleMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcSolidAngleMeasure::IfcSolidAngleMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcSolidAngleMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcSoundPowerMeasure
const IfcParse::type_declaration& Ifc2x3::IfcSoundPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[774]); }
const IfcParse::type_declaration& Ifc2x3::IfcSoundPowerMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[774]); }
Ifc2x3::IfcSoundPowerMeasure::IfcSoundPowerMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcSoundPowerMeasure::IfcSoundPowerMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcSoundPowerMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcSoundPressureMeasure
const IfcParse::type_declaration& Ifc2x3::IfcSoundPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[775]); }
const IfcParse::type_declaration& Ifc2x3::IfcSoundPressureMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[775]); }
Ifc2x3::IfcSoundPressureMeasure::IfcSoundPressureMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcSoundPressureMeasure::IfcSoundPressureMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcSoundPressureMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcSpecificHeatCapacityMeasure
const IfcParse::type_declaration& Ifc2x3::IfcSpecificHeatCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[788]); }
const IfcParse::type_declaration& Ifc2x3::IfcSpecificHeatCapacityMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[788]); }
Ifc2x3::IfcSpecificHeatCapacityMeasure::IfcSpecificHeatCapacityMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcSpecificHeatCapacityMeasure::IfcSpecificHeatCapacityMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcSpecificHeatCapacityMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcSpecularExponent
const IfcParse::type_declaration& Ifc2x3::IfcSpecularExponent::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[789]); }
const IfcParse::type_declaration& Ifc2x3::IfcSpecularExponent::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[789]); }
Ifc2x3::IfcSpecularExponent::IfcSpecularExponent(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcSpecularExponent::IfcSpecularExponent(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcSpecularExponent::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcSpecularRoughness
const IfcParse::type_declaration& Ifc2x3::IfcSpecularRoughness::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[791]); }
const IfcParse::type_declaration& Ifc2x3::IfcSpecularRoughness::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[791]); }
Ifc2x3::IfcSpecularRoughness::IfcSpecularRoughness(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcSpecularRoughness::IfcSpecularRoughness(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcSpecularRoughness::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcTemperatureGradientMeasure
const IfcParse::type_declaration& Ifc2x3::IfcTemperatureGradientMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[874]); }
const IfcParse::type_declaration& Ifc2x3::IfcTemperatureGradientMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[874]); }
Ifc2x3::IfcTemperatureGradientMeasure::IfcTemperatureGradientMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcTemperatureGradientMeasure::IfcTemperatureGradientMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcTemperatureGradientMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcText
const IfcParse::type_declaration& Ifc2x3::IfcText::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[879]); }
const IfcParse::type_declaration& Ifc2x3::IfcText::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[879]); }
Ifc2x3::IfcText::IfcText(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcText::IfcText(std::string v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcText::operator std::string() const { return get_attribute_value(0); }

// Function implementations for IfcTextAlignment
const IfcParse::type_declaration& Ifc2x3::IfcTextAlignment::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[880]); }
const IfcParse::type_declaration& Ifc2x3::IfcTextAlignment::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[880]); }
Ifc2x3::IfcTextAlignment::IfcTextAlignment(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcTextAlignment::IfcTextAlignment(std::string v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcTextAlignment::operator std::string() const { return get_attribute_value(0); }

// Function implementations for IfcTextDecoration
const IfcParse::type_declaration& Ifc2x3::IfcTextDecoration::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[881]); }
const IfcParse::type_declaration& Ifc2x3::IfcTextDecoration::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[881]); }
Ifc2x3::IfcTextDecoration::IfcTextDecoration(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcTextDecoration::IfcTextDecoration(std::string v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcTextDecoration::operator std::string() const { return get_attribute_value(0); }

// Function implementations for IfcTextFontName
const IfcParse::type_declaration& Ifc2x3::IfcTextFontName::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[882]); }
const IfcParse::type_declaration& Ifc2x3::IfcTextFontName::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[882]); }
Ifc2x3::IfcTextFontName::IfcTextFontName(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcTextFontName::IfcTextFontName(std::string v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcTextFontName::operator std::string() const { return get_attribute_value(0); }

// Function implementations for IfcTextTransformation
const IfcParse::type_declaration& Ifc2x3::IfcTextTransformation::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[893]); }
const IfcParse::type_declaration& Ifc2x3::IfcTextTransformation::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[893]); }
Ifc2x3::IfcTextTransformation::IfcTextTransformation(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcTextTransformation::IfcTextTransformation(std::string v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcTextTransformation::operator std::string() const { return get_attribute_value(0); }

// Function implementations for IfcThermalAdmittanceMeasure
const IfcParse::type_declaration& Ifc2x3::IfcThermalAdmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[898]); }
const IfcParse::type_declaration& Ifc2x3::IfcThermalAdmittanceMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[898]); }
Ifc2x3::IfcThermalAdmittanceMeasure::IfcThermalAdmittanceMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcThermalAdmittanceMeasure::IfcThermalAdmittanceMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcThermalAdmittanceMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcThermalConductivityMeasure
const IfcParse::type_declaration& Ifc2x3::IfcThermalConductivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[899]); }
const IfcParse::type_declaration& Ifc2x3::IfcThermalConductivityMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[899]); }
Ifc2x3::IfcThermalConductivityMeasure::IfcThermalConductivityMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcThermalConductivityMeasure::IfcThermalConductivityMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcThermalConductivityMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcThermalExpansionCoefficientMeasure
const IfcParse::type_declaration& Ifc2x3::IfcThermalExpansionCoefficientMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[900]); }
const IfcParse::type_declaration& Ifc2x3::IfcThermalExpansionCoefficientMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[900]); }
Ifc2x3::IfcThermalExpansionCoefficientMeasure::IfcThermalExpansionCoefficientMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcThermalExpansionCoefficientMeasure::IfcThermalExpansionCoefficientMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcThermalExpansionCoefficientMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcThermalResistanceMeasure
const IfcParse::type_declaration& Ifc2x3::IfcThermalResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[904]); }
const IfcParse::type_declaration& Ifc2x3::IfcThermalResistanceMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[904]); }
Ifc2x3::IfcThermalResistanceMeasure::IfcThermalResistanceMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcThermalResistanceMeasure::IfcThermalResistanceMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcThermalResistanceMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcThermalTransmittanceMeasure
const IfcParse::type_declaration& Ifc2x3::IfcThermalTransmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[905]); }
const IfcParse::type_declaration& Ifc2x3::IfcThermalTransmittanceMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[905]); }
Ifc2x3::IfcThermalTransmittanceMeasure::IfcThermalTransmittanceMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcThermalTransmittanceMeasure::IfcThermalTransmittanceMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcThermalTransmittanceMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcThermodynamicTemperatureMeasure
const IfcParse::type_declaration& Ifc2x3::IfcThermodynamicTemperatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[906]); }
const IfcParse::type_declaration& Ifc2x3::IfcThermodynamicTemperatureMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[906]); }
Ifc2x3::IfcThermodynamicTemperatureMeasure::IfcThermodynamicTemperatureMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcThermodynamicTemperatureMeasure::IfcThermodynamicTemperatureMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcThermodynamicTemperatureMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcTimeMeasure
const IfcParse::type_declaration& Ifc2x3::IfcTimeMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[907]); }
const IfcParse::type_declaration& Ifc2x3::IfcTimeMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[907]); }
Ifc2x3::IfcTimeMeasure::IfcTimeMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcTimeMeasure::IfcTimeMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcTimeMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcTimeStamp
const IfcParse::type_declaration& Ifc2x3::IfcTimeStamp::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[914]); }
const IfcParse::type_declaration& Ifc2x3::IfcTimeStamp::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[914]); }
Ifc2x3::IfcTimeStamp::IfcTimeStamp(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcTimeStamp::IfcTimeStamp(int v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcTimeStamp::operator int() const { return get_attribute_value(0); }

// Function implementations for IfcTorqueMeasure
const IfcParse::type_declaration& Ifc2x3::IfcTorqueMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[917]); }
const IfcParse::type_declaration& Ifc2x3::IfcTorqueMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[917]); }
Ifc2x3::IfcTorqueMeasure::IfcTorqueMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcTorqueMeasure::IfcTorqueMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcTorqueMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcVaporPermeabilityMeasure
const IfcParse::type_declaration& Ifc2x3::IfcVaporPermeabilityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[943]); }
const IfcParse::type_declaration& Ifc2x3::IfcVaporPermeabilityMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[943]); }
Ifc2x3::IfcVaporPermeabilityMeasure::IfcVaporPermeabilityMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcVaporPermeabilityMeasure::IfcVaporPermeabilityMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcVaporPermeabilityMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcVolumeMeasure
const IfcParse::type_declaration& Ifc2x3::IfcVolumeMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[954]); }
const IfcParse::type_declaration& Ifc2x3::IfcVolumeMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[954]); }
Ifc2x3::IfcVolumeMeasure::IfcVolumeMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcVolumeMeasure::IfcVolumeMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcVolumeMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcVolumetricFlowRateMeasure
const IfcParse::type_declaration& Ifc2x3::IfcVolumetricFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[955]); }
const IfcParse::type_declaration& Ifc2x3::IfcVolumetricFlowRateMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[955]); }
Ifc2x3::IfcVolumetricFlowRateMeasure::IfcVolumetricFlowRateMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcVolumetricFlowRateMeasure::IfcVolumetricFlowRateMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcVolumetricFlowRateMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcWarpingConstantMeasure
const IfcParse::type_declaration& Ifc2x3::IfcWarpingConstantMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[960]); }
const IfcParse::type_declaration& Ifc2x3::IfcWarpingConstantMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[960]); }
Ifc2x3::IfcWarpingConstantMeasure::IfcWarpingConstantMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcWarpingConstantMeasure::IfcWarpingConstantMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcWarpingConstantMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcWarpingMomentMeasure
const IfcParse::type_declaration& Ifc2x3::IfcWarpingMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[961]); }
const IfcParse::type_declaration& Ifc2x3::IfcWarpingMomentMeasure::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[961]); }
Ifc2x3::IfcWarpingMomentMeasure::IfcWarpingMomentMeasure(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcWarpingMomentMeasure::IfcWarpingMomentMeasure(double v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcWarpingMomentMeasure::operator double() const { return get_attribute_value(0); }

// Function implementations for IfcYearNumber
const IfcParse::type_declaration& Ifc2x3::IfcYearNumber::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[977]); }
const IfcParse::type_declaration& Ifc2x3::IfcYearNumber::declaration() const { return *((IfcParse::type_declaration*)IFC2X3_types[977]); }
Ifc2x3::IfcYearNumber::IfcYearNumber(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseType(std::move(e)) {  }
Ifc2x3::IfcYearNumber::IfcYearNumber(int v) : IfcUtil::IfcBaseType() { set_attribute_value(0, v); }
Ifc2x3::IfcYearNumber::operator int() const { return get_attribute_value(0); }


// Function implementations for Ifc2DCompositeCurve


const IfcParse::entity& Ifc2x3::Ifc2DCompositeCurve::declaration() const { return *((IfcParse::entity*)IFC2X3_types[0]); }
const IfcParse::entity& Ifc2x3::Ifc2DCompositeCurve::Class() { return *((IfcParse::entity*)IFC2X3_types[0]); }
Ifc2x3::Ifc2DCompositeCurve::Ifc2DCompositeCurve(IfcEntityInstanceData&& e) : IfcCompositeCurve(std::move(e)) { }
Ifc2x3::Ifc2DCompositeCurve::Ifc2DCompositeCurve(aggregate_of< ::Ifc2x3::IfcCompositeCurveSegment >::ptr v1_Segments, boost::logic::tribool v2_SelfIntersect) : IfcCompositeCurve(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (v1_Segments)->generalize());set_attribute_value(1, (v2_SelfIntersect));; populate_derived(); }

// Function implementations for IfcActionRequest
std::string Ifc2x3::IfcActionRequest::RequestID() const {  std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcActionRequest::setRequestID(std::string v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcActionRequest::declaration() const { return *((IfcParse::entity*)IFC2X3_types[3]); }
const IfcParse::entity& Ifc2x3::IfcActionRequest::Class() { return *((IfcParse::entity*)IFC2X3_types[3]); }
Ifc2x3::IfcActionRequest::IfcActionRequest(IfcEntityInstanceData&& e) : IfcControl(std::move(e)) { }
Ifc2x3::IfcActionRequest::IfcActionRequest(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_RequestID) : IfcControl(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (v6_RequestID));; populate_derived(); }

// Function implementations for IfcActor
::Ifc2x3::IfcActorSelect* Ifc2x3::IfcActor::TheActor() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcActorSelect>(true); }
void Ifc2x3::IfcActor::setTheActor(::Ifc2x3::IfcActorSelect* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }

::Ifc2x3::IfcRelAssignsToActor::list::ptr Ifc2x3::IfcActor::IsActingUpon() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[670], 6)->as<IfcRelAssignsToActor>(); }

const IfcParse::entity& Ifc2x3::IfcActor::declaration() const { return *((IfcParse::entity*)IFC2X3_types[6]); }
const IfcParse::entity& Ifc2x3::IfcActor::Class() { return *((IfcParse::entity*)IFC2X3_types[6]); }
Ifc2x3::IfcActor::IfcActor(IfcEntityInstanceData&& e) : IfcObject(std::move(e)) { }
Ifc2x3::IfcActor::IfcActor(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcActorSelect* v6_TheActor) : IfcObject(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_TheActor ? v6_TheActor->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcActorRole
::Ifc2x3::IfcRoleEnum::Value Ifc2x3::IfcActorRole::Role() const {  return ::Ifc2x3::IfcRoleEnum::FromString(get_attribute_value(0)); }
void Ifc2x3::IfcActorRole::setRole(::Ifc2x3::IfcRoleEnum::Value v) { set_attribute_value(0, EnumerationReference(&::Ifc2x3::IfcRoleEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(0); }
boost::optional< std::string > Ifc2x3::IfcActorRole::UserDefinedRole() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcActorRole::setUserDefinedRole(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< std::string > Ifc2x3::IfcActorRole::Description() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcActorRole::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }


const IfcParse::entity& Ifc2x3::IfcActorRole::declaration() const { return *((IfcParse::entity*)IFC2X3_types[7]); }
const IfcParse::entity& Ifc2x3::IfcActorRole::Class() { return *((IfcParse::entity*)IFC2X3_types[7]); }
Ifc2x3::IfcActorRole::IfcActorRole(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcActorRole::IfcActorRole(::Ifc2x3::IfcRoleEnum::Value v1_Role, boost::optional< std::string > v2_UserDefinedRole, boost::optional< std::string > v3_Description) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcRoleEnum::Class(),(size_t)v1_Role))); if (v2_UserDefinedRole) {set_attribute_value(1, (*v2_UserDefinedRole)); } if (v3_Description) {set_attribute_value(2, (*v3_Description)); }; populate_derived(); }

// Function implementations for IfcActuatorType
::Ifc2x3::IfcActuatorTypeEnum::Value Ifc2x3::IfcActuatorType::PredefinedType() const {  return ::Ifc2x3::IfcActuatorTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcActuatorType::setPredefinedType(::Ifc2x3::IfcActuatorTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcActuatorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcActuatorType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[9]); }
const IfcParse::entity& Ifc2x3::IfcActuatorType::Class() { return *((IfcParse::entity*)IFC2X3_types[9]); }
Ifc2x3::IfcActuatorType::IfcActuatorType(IfcEntityInstanceData&& e) : IfcDistributionControlElementType(std::move(e)) { }
Ifc2x3::IfcActuatorType::IfcActuatorType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcActuatorTypeEnum::Value v10_PredefinedType) : IfcDistributionControlElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcActuatorTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcAddress
boost::optional< ::Ifc2x3::IfcAddressTypeEnum::Value > Ifc2x3::IfcAddress::Purpose() const { if(get_attribute_value(0).isNull()) { return boost::none; } return ::Ifc2x3::IfcAddressTypeEnum::FromString(get_attribute_value(0)); }
void Ifc2x3::IfcAddress::setPurpose(boost::optional< ::Ifc2x3::IfcAddressTypeEnum::Value > v) { if (v) {set_attribute_value(0, EnumerationReference(&::Ifc2x3::IfcAddressTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(0);} }
boost::optional< std::string > Ifc2x3::IfcAddress::Description() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcAddress::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< std::string > Ifc2x3::IfcAddress::UserDefinedPurpose() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcAddress::setUserDefinedPurpose(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }

::Ifc2x3::IfcPerson::list::ptr Ifc2x3::IfcAddress::OfPerson() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[545], 7)->as<IfcPerson>(); }
::Ifc2x3::IfcOrganization::list::ptr Ifc2x3::IfcAddress::OfOrganization() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[531], 4)->as<IfcOrganization>(); }

const IfcParse::entity& Ifc2x3::IfcAddress::declaration() const { return *((IfcParse::entity*)IFC2X3_types[11]); }
const IfcParse::entity& Ifc2x3::IfcAddress::Class() { return *((IfcParse::entity*)IFC2X3_types[11]); }
Ifc2x3::IfcAddress::IfcAddress(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcAddress::IfcAddress(boost::optional< ::Ifc2x3::IfcAddressTypeEnum::Value > v1_Purpose, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_UserDefinedPurpose) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) {  if (v1_Purpose) {set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcAddressTypeEnum::Class(),(size_t)*v1_Purpose))); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); } if (v3_UserDefinedPurpose) {set_attribute_value(2, (*v3_UserDefinedPurpose)); }; populate_derived(); }

// Function implementations for IfcAirTerminalBoxType
::Ifc2x3::IfcAirTerminalBoxTypeEnum::Value Ifc2x3::IfcAirTerminalBoxType::PredefinedType() const {  return ::Ifc2x3::IfcAirTerminalBoxTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcAirTerminalBoxType::setPredefinedType(::Ifc2x3::IfcAirTerminalBoxTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcAirTerminalBoxTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcAirTerminalBoxType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[14]); }
const IfcParse::entity& Ifc2x3::IfcAirTerminalBoxType::Class() { return *((IfcParse::entity*)IFC2X3_types[14]); }
Ifc2x3::IfcAirTerminalBoxType::IfcAirTerminalBoxType(IfcEntityInstanceData&& e) : IfcFlowControllerType(std::move(e)) { }
Ifc2x3::IfcAirTerminalBoxType::IfcAirTerminalBoxType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcAirTerminalBoxTypeEnum::Value v10_PredefinedType) : IfcFlowControllerType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcAirTerminalBoxTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcAirTerminalType
::Ifc2x3::IfcAirTerminalTypeEnum::Value Ifc2x3::IfcAirTerminalType::PredefinedType() const {  return ::Ifc2x3::IfcAirTerminalTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcAirTerminalType::setPredefinedType(::Ifc2x3::IfcAirTerminalTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcAirTerminalTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcAirTerminalType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[16]); }
const IfcParse::entity& Ifc2x3::IfcAirTerminalType::Class() { return *((IfcParse::entity*)IFC2X3_types[16]); }
Ifc2x3::IfcAirTerminalType::IfcAirTerminalType(IfcEntityInstanceData&& e) : IfcFlowTerminalType(std::move(e)) { }
Ifc2x3::IfcAirTerminalType::IfcAirTerminalType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcAirTerminalTypeEnum::Value v10_PredefinedType) : IfcFlowTerminalType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcAirTerminalTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcAirToAirHeatRecoveryType
::Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::Value Ifc2x3::IfcAirToAirHeatRecoveryType::PredefinedType() const {  return ::Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcAirToAirHeatRecoveryType::setPredefinedType(::Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcAirToAirHeatRecoveryType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[18]); }
const IfcParse::entity& Ifc2x3::IfcAirToAirHeatRecoveryType::Class() { return *((IfcParse::entity*)IFC2X3_types[18]); }
Ifc2x3::IfcAirToAirHeatRecoveryType::IfcAirToAirHeatRecoveryType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcAirToAirHeatRecoveryType::IfcAirToAirHeatRecoveryType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcAirToAirHeatRecoveryTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcAlarmType
::Ifc2x3::IfcAlarmTypeEnum::Value Ifc2x3::IfcAlarmType::PredefinedType() const {  return ::Ifc2x3::IfcAlarmTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcAlarmType::setPredefinedType(::Ifc2x3::IfcAlarmTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcAlarmTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcAlarmType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[20]); }
const IfcParse::entity& Ifc2x3::IfcAlarmType::Class() { return *((IfcParse::entity*)IFC2X3_types[20]); }
Ifc2x3::IfcAlarmType::IfcAlarmType(IfcEntityInstanceData&& e) : IfcDistributionControlElementType(std::move(e)) { }
Ifc2x3::IfcAlarmType::IfcAlarmType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcAlarmTypeEnum::Value v10_PredefinedType) : IfcDistributionControlElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcAlarmTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcAngularDimension


const IfcParse::entity& Ifc2x3::IfcAngularDimension::declaration() const { return *((IfcParse::entity*)IFC2X3_types[25]); }
const IfcParse::entity& Ifc2x3::IfcAngularDimension::Class() { return *((IfcParse::entity*)IFC2X3_types[25]); }
Ifc2x3::IfcAngularDimension::IfcAngularDimension(IfcEntityInstanceData&& e) : IfcDimensionCurveDirectedCallout(std::move(e)) { }
Ifc2x3::IfcAngularDimension::IfcAngularDimension(aggregate_of< ::Ifc2x3::IfcDraughtingCalloutElement >::ptr v1_Contents) : IfcDimensionCurveDirectedCallout(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Contents)->generalize());; populate_derived(); }

// Function implementations for IfcAnnotation

::Ifc2x3::IfcRelContainedInSpatialStructure::list::ptr Ifc2x3::IfcAnnotation::ContainedInStructure() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[698], 4)->as<IfcRelContainedInSpatialStructure>(); }

const IfcParse::entity& Ifc2x3::IfcAnnotation::declaration() const { return *((IfcParse::entity*)IFC2X3_types[27]); }
const IfcParse::entity& Ifc2x3::IfcAnnotation::Class() { return *((IfcParse::entity*)IFC2X3_types[27]); }
Ifc2x3::IfcAnnotation::IfcAnnotation(IfcEntityInstanceData&& e) : IfcProduct(std::move(e)) { }
Ifc2x3::IfcAnnotation::IfcAnnotation(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation) : IfcProduct(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcAnnotationCurveOccurrence


const IfcParse::entity& Ifc2x3::IfcAnnotationCurveOccurrence::declaration() const { return *((IfcParse::entity*)IFC2X3_types[28]); }
const IfcParse::entity& Ifc2x3::IfcAnnotationCurveOccurrence::Class() { return *((IfcParse::entity*)IFC2X3_types[28]); }
Ifc2x3::IfcAnnotationCurveOccurrence::IfcAnnotationCurveOccurrence(IfcEntityInstanceData&& e) : IfcAnnotationOccurrence(std::move(e)) { }
Ifc2x3::IfcAnnotationCurveOccurrence::IfcAnnotationCurveOccurrence(::Ifc2x3::IfcRepresentationItem* v1_Item, aggregate_of< ::Ifc2x3::IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationOccurrence(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_Item ? v1_Item->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Styles)->generalize()); if (v3_Name) {set_attribute_value(2, (*v3_Name)); }; populate_derived(); }

// Function implementations for IfcAnnotationFillArea
::Ifc2x3::IfcCurve* Ifc2x3::IfcAnnotationFillArea::OuterBoundary() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcCurve>(true); }
void Ifc2x3::IfcAnnotationFillArea::setOuterBoundary(::Ifc2x3::IfcCurve* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
boost::optional< aggregate_of< ::Ifc2x3::IfcCurve >::ptr > Ifc2x3::IfcAnnotationFillArea::InnerBoundaries() const { if(get_attribute_value(1).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcCurve >(); }
void Ifc2x3::IfcAnnotationFillArea::setInnerBoundaries(boost::optional< aggregate_of< ::Ifc2x3::IfcCurve >::ptr > v) { if (v) {set_attribute_value(1, (*v)->generalize());} else {unset_attribute_value(1);} }


const IfcParse::entity& Ifc2x3::IfcAnnotationFillArea::declaration() const { return *((IfcParse::entity*)IFC2X3_types[29]); }
const IfcParse::entity& Ifc2x3::IfcAnnotationFillArea::Class() { return *((IfcParse::entity*)IFC2X3_types[29]); }
Ifc2x3::IfcAnnotationFillArea::IfcAnnotationFillArea(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcAnnotationFillArea::IfcAnnotationFillArea(::Ifc2x3::IfcCurve* v1_OuterBoundary, boost::optional< aggregate_of< ::Ifc2x3::IfcCurve >::ptr > v2_InnerBoundaries) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_OuterBoundary ? v1_OuterBoundary->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_InnerBoundaries) {set_attribute_value(1, (*v2_InnerBoundaries)->generalize()); }; populate_derived(); }

// Function implementations for IfcAnnotationFillAreaOccurrence
::Ifc2x3::IfcPoint* Ifc2x3::IfcAnnotationFillAreaOccurrence::FillStyleTarget() const { if(get_attribute_value(3).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcPoint>(true); }
void Ifc2x3::IfcAnnotationFillAreaOccurrence::setFillStyleTarget(::Ifc2x3::IfcPoint* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }
boost::optional< ::Ifc2x3::IfcGlobalOrLocalEnum::Value > Ifc2x3::IfcAnnotationFillAreaOccurrence::GlobalOrLocal() const { if(get_attribute_value(4).isNull()) { return boost::none; } return ::Ifc2x3::IfcGlobalOrLocalEnum::FromString(get_attribute_value(4)); }
void Ifc2x3::IfcAnnotationFillAreaOccurrence::setGlobalOrLocal(boost::optional< ::Ifc2x3::IfcGlobalOrLocalEnum::Value > v) { if (v) {set_attribute_value(4, EnumerationReference(&::Ifc2x3::IfcGlobalOrLocalEnum::Class(), (size_t) *v));} else {unset_attribute_value(4);} }


const IfcParse::entity& Ifc2x3::IfcAnnotationFillAreaOccurrence::declaration() const { return *((IfcParse::entity*)IFC2X3_types[30]); }
const IfcParse::entity& Ifc2x3::IfcAnnotationFillAreaOccurrence::Class() { return *((IfcParse::entity*)IFC2X3_types[30]); }
Ifc2x3::IfcAnnotationFillAreaOccurrence::IfcAnnotationFillAreaOccurrence(IfcEntityInstanceData&& e) : IfcAnnotationOccurrence(std::move(e)) { }
Ifc2x3::IfcAnnotationFillAreaOccurrence::IfcAnnotationFillAreaOccurrence(::Ifc2x3::IfcRepresentationItem* v1_Item, aggregate_of< ::Ifc2x3::IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name, ::Ifc2x3::IfcPoint* v4_FillStyleTarget, boost::optional< ::Ifc2x3::IfcGlobalOrLocalEnum::Value > v5_GlobalOrLocal) : IfcAnnotationOccurrence(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, v1_Item ? v1_Item->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Styles)->generalize()); if (v3_Name) {set_attribute_value(2, (*v3_Name)); }set_attribute_value(3, v4_FillStyleTarget ? v4_FillStyleTarget->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v5_GlobalOrLocal) {set_attribute_value(4, (EnumerationReference(&::Ifc2x3::IfcGlobalOrLocalEnum::Class(),(size_t)*v5_GlobalOrLocal))); }; populate_derived(); }

// Function implementations for IfcAnnotationOccurrence


const IfcParse::entity& Ifc2x3::IfcAnnotationOccurrence::declaration() const { return *((IfcParse::entity*)IFC2X3_types[31]); }
const IfcParse::entity& Ifc2x3::IfcAnnotationOccurrence::Class() { return *((IfcParse::entity*)IFC2X3_types[31]); }
Ifc2x3::IfcAnnotationOccurrence::IfcAnnotationOccurrence(IfcEntityInstanceData&& e) : IfcStyledItem(std::move(e)) { }
Ifc2x3::IfcAnnotationOccurrence::IfcAnnotationOccurrence(::Ifc2x3::IfcRepresentationItem* v1_Item, aggregate_of< ::Ifc2x3::IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcStyledItem(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_Item ? v1_Item->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Styles)->generalize()); if (v3_Name) {set_attribute_value(2, (*v3_Name)); }; populate_derived(); }

// Function implementations for IfcAnnotationSurface
::Ifc2x3::IfcGeometricRepresentationItem* Ifc2x3::IfcAnnotationSurface::Item() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcGeometricRepresentationItem>(true); }
void Ifc2x3::IfcAnnotationSurface::setItem(::Ifc2x3::IfcGeometricRepresentationItem* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcTextureCoordinate* Ifc2x3::IfcAnnotationSurface::TextureCoordinates() const { if(get_attribute_value(1).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcTextureCoordinate>(true); }
void Ifc2x3::IfcAnnotationSurface::setTextureCoordinates(::Ifc2x3::IfcTextureCoordinate* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcAnnotationSurface::declaration() const { return *((IfcParse::entity*)IFC2X3_types[32]); }
const IfcParse::entity& Ifc2x3::IfcAnnotationSurface::Class() { return *((IfcParse::entity*)IFC2X3_types[32]); }
Ifc2x3::IfcAnnotationSurface::IfcAnnotationSurface(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcAnnotationSurface::IfcAnnotationSurface(::Ifc2x3::IfcGeometricRepresentationItem* v1_Item, ::Ifc2x3::IfcTextureCoordinate* v2_TextureCoordinates) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_Item ? v1_Item->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_TextureCoordinates ? v2_TextureCoordinates->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcAnnotationSurfaceOccurrence


const IfcParse::entity& Ifc2x3::IfcAnnotationSurfaceOccurrence::declaration() const { return *((IfcParse::entity*)IFC2X3_types[33]); }
const IfcParse::entity& Ifc2x3::IfcAnnotationSurfaceOccurrence::Class() { return *((IfcParse::entity*)IFC2X3_types[33]); }
Ifc2x3::IfcAnnotationSurfaceOccurrence::IfcAnnotationSurfaceOccurrence(IfcEntityInstanceData&& e) : IfcAnnotationOccurrence(std::move(e)) { }
Ifc2x3::IfcAnnotationSurfaceOccurrence::IfcAnnotationSurfaceOccurrence(::Ifc2x3::IfcRepresentationItem* v1_Item, aggregate_of< ::Ifc2x3::IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationOccurrence(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_Item ? v1_Item->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Styles)->generalize()); if (v3_Name) {set_attribute_value(2, (*v3_Name)); }; populate_derived(); }

// Function implementations for IfcAnnotationSymbolOccurrence


const IfcParse::entity& Ifc2x3::IfcAnnotationSymbolOccurrence::declaration() const { return *((IfcParse::entity*)IFC2X3_types[34]); }
const IfcParse::entity& Ifc2x3::IfcAnnotationSymbolOccurrence::Class() { return *((IfcParse::entity*)IFC2X3_types[34]); }
Ifc2x3::IfcAnnotationSymbolOccurrence::IfcAnnotationSymbolOccurrence(IfcEntityInstanceData&& e) : IfcAnnotationOccurrence(std::move(e)) { }
Ifc2x3::IfcAnnotationSymbolOccurrence::IfcAnnotationSymbolOccurrence(::Ifc2x3::IfcRepresentationItem* v1_Item, aggregate_of< ::Ifc2x3::IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationOccurrence(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_Item ? v1_Item->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Styles)->generalize()); if (v3_Name) {set_attribute_value(2, (*v3_Name)); }; populate_derived(); }

// Function implementations for IfcAnnotationTextOccurrence


const IfcParse::entity& Ifc2x3::IfcAnnotationTextOccurrence::declaration() const { return *((IfcParse::entity*)IFC2X3_types[35]); }
const IfcParse::entity& Ifc2x3::IfcAnnotationTextOccurrence::Class() { return *((IfcParse::entity*)IFC2X3_types[35]); }
Ifc2x3::IfcAnnotationTextOccurrence::IfcAnnotationTextOccurrence(IfcEntityInstanceData&& e) : IfcAnnotationOccurrence(std::move(e)) { }
Ifc2x3::IfcAnnotationTextOccurrence::IfcAnnotationTextOccurrence(::Ifc2x3::IfcRepresentationItem* v1_Item, aggregate_of< ::Ifc2x3::IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationOccurrence(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_Item ? v1_Item->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Styles)->generalize()); if (v3_Name) {set_attribute_value(2, (*v3_Name)); }; populate_derived(); }

// Function implementations for IfcApplication
::Ifc2x3::IfcOrganization* Ifc2x3::IfcApplication::ApplicationDeveloper() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcOrganization>(true); }
void Ifc2x3::IfcApplication::setApplicationDeveloper(::Ifc2x3::IfcOrganization* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
std::string Ifc2x3::IfcApplication::Version() const {  std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcApplication::setVersion(std::string v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
std::string Ifc2x3::IfcApplication::ApplicationFullName() const {  std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcApplication::setApplicationFullName(std::string v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
std::string Ifc2x3::IfcApplication::ApplicationIdentifier() const {  std::string v = get_attribute_value(3); return v; }
void Ifc2x3::IfcApplication::setApplicationIdentifier(std::string v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcApplication::declaration() const { return *((IfcParse::entity*)IFC2X3_types[36]); }
const IfcParse::entity& Ifc2x3::IfcApplication::Class() { return *((IfcParse::entity*)IFC2X3_types[36]); }
Ifc2x3::IfcApplication::IfcApplication(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcApplication::IfcApplication(::Ifc2x3::IfcOrganization* v1_ApplicationDeveloper, std::string v2_Version, std::string v3_ApplicationFullName, std::string v4_ApplicationIdentifier) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_ApplicationDeveloper ? v1_ApplicationDeveloper->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Version));set_attribute_value(2, (v3_ApplicationFullName));set_attribute_value(3, (v4_ApplicationIdentifier));; populate_derived(); }

// Function implementations for IfcAppliedValue
boost::optional< std::string > Ifc2x3::IfcAppliedValue::Name() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcAppliedValue::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
boost::optional< std::string > Ifc2x3::IfcAppliedValue::Description() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcAppliedValue::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
::Ifc2x3::IfcAppliedValueSelect* Ifc2x3::IfcAppliedValue::AppliedValue() const { if(get_attribute_value(2).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcAppliedValueSelect>(true); }
void Ifc2x3::IfcAppliedValue::setAppliedValue(::Ifc2x3::IfcAppliedValueSelect* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcMeasureWithUnit* Ifc2x3::IfcAppliedValue::UnitBasis() const { if(get_attribute_value(3).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcMeasureWithUnit>(true); }
void Ifc2x3::IfcAppliedValue::setUnitBasis(::Ifc2x3::IfcMeasureWithUnit* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcAppliedValue::ApplicableDate() const { if(get_attribute_value(4).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcAppliedValue::setApplicableDate(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcAppliedValue::FixedUntilDate() const { if(get_attribute_value(5).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcAppliedValue::setFixedUntilDate(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }

::Ifc2x3::IfcReferencesValueDocument::list::ptr Ifc2x3::IfcAppliedValue::ValuesReferenced() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[657], 1)->as<IfcReferencesValueDocument>(); }
::Ifc2x3::IfcAppliedValueRelationship::list::ptr Ifc2x3::IfcAppliedValue::ValueOfComponents() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[38], 0)->as<IfcAppliedValueRelationship>(); }
::Ifc2x3::IfcAppliedValueRelationship::list::ptr Ifc2x3::IfcAppliedValue::IsComponentIn() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[38], 1)->as<IfcAppliedValueRelationship>(); }

const IfcParse::entity& Ifc2x3::IfcAppliedValue::declaration() const { return *((IfcParse::entity*)IFC2X3_types[37]); }
const IfcParse::entity& Ifc2x3::IfcAppliedValue::Class() { return *((IfcParse::entity*)IFC2X3_types[37]); }
Ifc2x3::IfcAppliedValue::IfcAppliedValue(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcAppliedValue::IfcAppliedValue(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcAppliedValueSelect* v3_AppliedValue, ::Ifc2x3::IfcMeasureWithUnit* v4_UnitBasis, ::Ifc2x3::IfcDateTimeSelect* v5_ApplicableDate, ::Ifc2x3::IfcDateTimeSelect* v6_FixedUntilDate) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(6))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_AppliedValue ? v3_AppliedValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_UnitBasis ? v4_UnitBasis->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(4, v5_ApplicableDate ? v5_ApplicableDate->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_FixedUntilDate ? v6_FixedUntilDate->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcAppliedValueRelationship
::Ifc2x3::IfcAppliedValue* Ifc2x3::IfcAppliedValueRelationship::ComponentOfTotal() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcAppliedValue>(true); }
void Ifc2x3::IfcAppliedValueRelationship::setComponentOfTotal(::Ifc2x3::IfcAppliedValue* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcAppliedValue >::ptr Ifc2x3::IfcAppliedValueRelationship::Components() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcAppliedValue >(); }
void Ifc2x3::IfcAppliedValueRelationship::setComponents(aggregate_of< ::Ifc2x3::IfcAppliedValue >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcArithmeticOperatorEnum::Value Ifc2x3::IfcAppliedValueRelationship::ArithmeticOperator() const {  return ::Ifc2x3::IfcArithmeticOperatorEnum::FromString(get_attribute_value(2)); }
void Ifc2x3::IfcAppliedValueRelationship::setArithmeticOperator(::Ifc2x3::IfcArithmeticOperatorEnum::Value v) { set_attribute_value(2, EnumerationReference(&::Ifc2x3::IfcArithmeticOperatorEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(2); }
boost::optional< std::string > Ifc2x3::IfcAppliedValueRelationship::Name() const { if(get_attribute_value(3).isNull()) { return boost::none; } std::string v = get_attribute_value(3); return v; }
void Ifc2x3::IfcAppliedValueRelationship::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< std::string > Ifc2x3::IfcAppliedValueRelationship::Description() const { if(get_attribute_value(4).isNull()) { return boost::none; } std::string v = get_attribute_value(4); return v; }
void Ifc2x3::IfcAppliedValueRelationship::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }


const IfcParse::entity& Ifc2x3::IfcAppliedValueRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[38]); }
const IfcParse::entity& Ifc2x3::IfcAppliedValueRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[38]); }
Ifc2x3::IfcAppliedValueRelationship::IfcAppliedValueRelationship(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcAppliedValueRelationship::IfcAppliedValueRelationship(::Ifc2x3::IfcAppliedValue* v1_ComponentOfTotal, aggregate_of< ::Ifc2x3::IfcAppliedValue >::ptr v2_Components, ::Ifc2x3::IfcArithmeticOperatorEnum::Value v3_ArithmeticOperator, boost::optional< std::string > v4_Name, boost::optional< std::string > v5_Description) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, v1_ComponentOfTotal ? v1_ComponentOfTotal->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Components)->generalize());set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcArithmeticOperatorEnum::Class(),(size_t)v3_ArithmeticOperator))); if (v4_Name) {set_attribute_value(3, (*v4_Name)); } if (v5_Description) {set_attribute_value(4, (*v5_Description)); }; populate_derived(); }

// Function implementations for IfcApproval
boost::optional< std::string > Ifc2x3::IfcApproval::Description() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcApproval::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcApproval::ApprovalDateTime() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcApproval::setApprovalDateTime(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
boost::optional< std::string > Ifc2x3::IfcApproval::ApprovalStatus() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcApproval::setApprovalStatus(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< std::string > Ifc2x3::IfcApproval::ApprovalLevel() const { if(get_attribute_value(3).isNull()) { return boost::none; } std::string v = get_attribute_value(3); return v; }
void Ifc2x3::IfcApproval::setApprovalLevel(boost::optional< std::string > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< std::string > Ifc2x3::IfcApproval::ApprovalQualifier() const { if(get_attribute_value(4).isNull()) { return boost::none; } std::string v = get_attribute_value(4); return v; }
void Ifc2x3::IfcApproval::setApprovalQualifier(boost::optional< std::string > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
std::string Ifc2x3::IfcApproval::Name() const {  std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcApproval::setName(std::string v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
std::string Ifc2x3::IfcApproval::Identifier() const {  std::string v = get_attribute_value(6); return v; }
void Ifc2x3::IfcApproval::setIdentifier(std::string v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }

::Ifc2x3::IfcApprovalActorRelationship::list::ptr Ifc2x3::IfcApproval::Actors() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[41], 1)->as<IfcApprovalActorRelationship>(); }
::Ifc2x3::IfcApprovalRelationship::list::ptr Ifc2x3::IfcApproval::IsRelatedWith() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[43], 0)->as<IfcApprovalRelationship>(); }
::Ifc2x3::IfcApprovalRelationship::list::ptr Ifc2x3::IfcApproval::Relates() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[43], 1)->as<IfcApprovalRelationship>(); }

const IfcParse::entity& Ifc2x3::IfcApproval::declaration() const { return *((IfcParse::entity*)IFC2X3_types[40]); }
const IfcParse::entity& Ifc2x3::IfcApproval::Class() { return *((IfcParse::entity*)IFC2X3_types[40]); }
Ifc2x3::IfcApproval::IfcApproval(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcApproval::IfcApproval(boost::optional< std::string > v1_Description, ::Ifc2x3::IfcDateTimeSelect* v2_ApprovalDateTime, boost::optional< std::string > v3_ApprovalStatus, boost::optional< std::string > v4_ApprovalLevel, boost::optional< std::string > v5_ApprovalQualifier, std::string v6_Name, std::string v7_Identifier) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(7))) {  if (v1_Description) {set_attribute_value(0, (*v1_Description)); }set_attribute_value(1, v2_ApprovalDateTime ? v2_ApprovalDateTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_ApprovalStatus) {set_attribute_value(2, (*v3_ApprovalStatus)); } if (v4_ApprovalLevel) {set_attribute_value(3, (*v4_ApprovalLevel)); } if (v5_ApprovalQualifier) {set_attribute_value(4, (*v5_ApprovalQualifier)); }set_attribute_value(5, (v6_Name));set_attribute_value(6, (v7_Identifier));; populate_derived(); }

// Function implementations for IfcApprovalActorRelationship
::Ifc2x3::IfcActorSelect* Ifc2x3::IfcApprovalActorRelationship::Actor() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcActorSelect>(true); }
void Ifc2x3::IfcApprovalActorRelationship::setActor(::Ifc2x3::IfcActorSelect* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcApproval* Ifc2x3::IfcApprovalActorRelationship::Approval() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcApproval>(true); }
void Ifc2x3::IfcApprovalActorRelationship::setApproval(::Ifc2x3::IfcApproval* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcActorRole* Ifc2x3::IfcApprovalActorRelationship::Role() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcActorRole>(true); }
void Ifc2x3::IfcApprovalActorRelationship::setRole(::Ifc2x3::IfcActorRole* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcApprovalActorRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[41]); }
const IfcParse::entity& Ifc2x3::IfcApprovalActorRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[41]); }
Ifc2x3::IfcApprovalActorRelationship::IfcApprovalActorRelationship(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcApprovalActorRelationship::IfcApprovalActorRelationship(::Ifc2x3::IfcActorSelect* v1_Actor, ::Ifc2x3::IfcApproval* v2_Approval, ::Ifc2x3::IfcActorRole* v3_Role) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_Actor ? v1_Actor->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_Approval ? v2_Approval->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_Role ? v3_Role->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcApprovalPropertyRelationship
aggregate_of< ::Ifc2x3::IfcProperty >::ptr Ifc2x3::IfcApprovalPropertyRelationship::ApprovedProperties() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcProperty >(); }
void Ifc2x3::IfcApprovalPropertyRelationship::setApprovedProperties(aggregate_of< ::Ifc2x3::IfcProperty >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcApproval* Ifc2x3::IfcApprovalPropertyRelationship::Approval() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcApproval>(true); }
void Ifc2x3::IfcApprovalPropertyRelationship::setApproval(::Ifc2x3::IfcApproval* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcApprovalPropertyRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[42]); }
const IfcParse::entity& Ifc2x3::IfcApprovalPropertyRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[42]); }
Ifc2x3::IfcApprovalPropertyRelationship::IfcApprovalPropertyRelationship(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcApprovalPropertyRelationship::IfcApprovalPropertyRelationship(aggregate_of< ::Ifc2x3::IfcProperty >::ptr v1_ApprovedProperties, ::Ifc2x3::IfcApproval* v2_Approval) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (v1_ApprovedProperties)->generalize());set_attribute_value(1, v2_Approval ? v2_Approval->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcApprovalRelationship
::Ifc2x3::IfcApproval* Ifc2x3::IfcApprovalRelationship::RelatedApproval() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcApproval>(true); }
void Ifc2x3::IfcApprovalRelationship::setRelatedApproval(::Ifc2x3::IfcApproval* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcApproval* Ifc2x3::IfcApprovalRelationship::RelatingApproval() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcApproval>(true); }
void Ifc2x3::IfcApprovalRelationship::setRelatingApproval(::Ifc2x3::IfcApproval* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
boost::optional< std::string > Ifc2x3::IfcApprovalRelationship::Description() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcApprovalRelationship::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
std::string Ifc2x3::IfcApprovalRelationship::Name() const {  std::string v = get_attribute_value(3); return v; }
void Ifc2x3::IfcApprovalRelationship::setName(std::string v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcApprovalRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[43]); }
const IfcParse::entity& Ifc2x3::IfcApprovalRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[43]); }
Ifc2x3::IfcApprovalRelationship::IfcApprovalRelationship(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcApprovalRelationship::IfcApprovalRelationship(::Ifc2x3::IfcApproval* v1_RelatedApproval, ::Ifc2x3::IfcApproval* v2_RelatingApproval, boost::optional< std::string > v3_Description, std::string v4_Name) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_RelatedApproval ? v1_RelatedApproval->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_RelatingApproval ? v2_RelatingApproval->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Description) {set_attribute_value(2, (*v3_Description)); }set_attribute_value(3, (v4_Name));; populate_derived(); }

// Function implementations for IfcArbitraryClosedProfileDef
::Ifc2x3::IfcCurve* Ifc2x3::IfcArbitraryClosedProfileDef::OuterCurve() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcCurve>(true); }
void Ifc2x3::IfcArbitraryClosedProfileDef::setOuterCurve(::Ifc2x3::IfcCurve* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcArbitraryClosedProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[44]); }
const IfcParse::entity& Ifc2x3::IfcArbitraryClosedProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[44]); }
Ifc2x3::IfcArbitraryClosedProfileDef::IfcArbitraryClosedProfileDef(IfcEntityInstanceData&& e) : IfcProfileDef(std::move(e)) { }
Ifc2x3::IfcArbitraryClosedProfileDef::IfcArbitraryClosedProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcCurve* v3_OuterCurve) : IfcProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_OuterCurve ? v3_OuterCurve->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcArbitraryOpenProfileDef
::Ifc2x3::IfcBoundedCurve* Ifc2x3::IfcArbitraryOpenProfileDef::Curve() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcBoundedCurve>(true); }
void Ifc2x3::IfcArbitraryOpenProfileDef::setCurve(::Ifc2x3::IfcBoundedCurve* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcArbitraryOpenProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[45]); }
const IfcParse::entity& Ifc2x3::IfcArbitraryOpenProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[45]); }
Ifc2x3::IfcArbitraryOpenProfileDef::IfcArbitraryOpenProfileDef(IfcEntityInstanceData&& e) : IfcProfileDef(std::move(e)) { }
Ifc2x3::IfcArbitraryOpenProfileDef::IfcArbitraryOpenProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcBoundedCurve* v3_Curve) : IfcProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Curve ? v3_Curve->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcArbitraryProfileDefWithVoids
aggregate_of< ::Ifc2x3::IfcCurve >::ptr Ifc2x3::IfcArbitraryProfileDefWithVoids::InnerCurves() const {  aggregate_of_instance::ptr es = get_attribute_value(3); return es->as< ::Ifc2x3::IfcCurve >(); }
void Ifc2x3::IfcArbitraryProfileDefWithVoids::setInnerCurves(aggregate_of< ::Ifc2x3::IfcCurve >::ptr v) { set_attribute_value(3, (v)->generalize());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcArbitraryProfileDefWithVoids::declaration() const { return *((IfcParse::entity*)IFC2X3_types[46]); }
const IfcParse::entity& Ifc2x3::IfcArbitraryProfileDefWithVoids::Class() { return *((IfcParse::entity*)IFC2X3_types[46]); }
Ifc2x3::IfcArbitraryProfileDefWithVoids::IfcArbitraryProfileDefWithVoids(IfcEntityInstanceData&& e) : IfcArbitraryClosedProfileDef(std::move(e)) { }
Ifc2x3::IfcArbitraryProfileDefWithVoids::IfcArbitraryProfileDefWithVoids(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcCurve* v3_OuterCurve, aggregate_of< ::Ifc2x3::IfcCurve >::ptr v4_InnerCurves) : IfcArbitraryClosedProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_OuterCurve ? v3_OuterCurve->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_InnerCurves)->generalize());; populate_derived(); }

// Function implementations for IfcAsset
std::string Ifc2x3::IfcAsset::AssetID() const {  std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcAsset::setAssetID(std::string v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcCostValue* Ifc2x3::IfcAsset::OriginalValue() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcCostValue>(true); }
void Ifc2x3::IfcAsset::setOriginalValue(::Ifc2x3::IfcCostValue* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
::Ifc2x3::IfcCostValue* Ifc2x3::IfcAsset::CurrentValue() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(7)))->as<::Ifc2x3::IfcCostValue>(true); }
void Ifc2x3::IfcAsset::setCurrentValue(::Ifc2x3::IfcCostValue* v) { set_attribute_value(7, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(7); }
::Ifc2x3::IfcCostValue* Ifc2x3::IfcAsset::TotalReplacementCost() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(8)))->as<::Ifc2x3::IfcCostValue>(true); }
void Ifc2x3::IfcAsset::setTotalReplacementCost(::Ifc2x3::IfcCostValue* v) { set_attribute_value(8, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(8); }
::Ifc2x3::IfcActorSelect* Ifc2x3::IfcAsset::Owner() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(9)))->as<::Ifc2x3::IfcActorSelect>(true); }
void Ifc2x3::IfcAsset::setOwner(::Ifc2x3::IfcActorSelect* v) { set_attribute_value(9, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(9); }
::Ifc2x3::IfcActorSelect* Ifc2x3::IfcAsset::User() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(10)))->as<::Ifc2x3::IfcActorSelect>(true); }
void Ifc2x3::IfcAsset::setUser(::Ifc2x3::IfcActorSelect* v) { set_attribute_value(10, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(10); }
::Ifc2x3::IfcPerson* Ifc2x3::IfcAsset::ResponsiblePerson() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(11)))->as<::Ifc2x3::IfcPerson>(true); }
void Ifc2x3::IfcAsset::setResponsiblePerson(::Ifc2x3::IfcPerson* v) { set_attribute_value(11, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(11); }
::Ifc2x3::IfcCalendarDate* Ifc2x3::IfcAsset::IncorporationDate() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(12)))->as<::Ifc2x3::IfcCalendarDate>(true); }
void Ifc2x3::IfcAsset::setIncorporationDate(::Ifc2x3::IfcCalendarDate* v) { set_attribute_value(12, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(12); }
::Ifc2x3::IfcCostValue* Ifc2x3::IfcAsset::DepreciatedValue() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(13)))->as<::Ifc2x3::IfcCostValue>(true); }
void Ifc2x3::IfcAsset::setDepreciatedValue(::Ifc2x3::IfcCostValue* v) { set_attribute_value(13, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(13); }


const IfcParse::entity& Ifc2x3::IfcAsset::declaration() const { return *((IfcParse::entity*)IFC2X3_types[50]); }
const IfcParse::entity& Ifc2x3::IfcAsset::Class() { return *((IfcParse::entity*)IFC2X3_types[50]); }
Ifc2x3::IfcAsset::IfcAsset(IfcEntityInstanceData&& e) : IfcGroup(std::move(e)) { }
Ifc2x3::IfcAsset::IfcAsset(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_AssetID, ::Ifc2x3::IfcCostValue* v7_OriginalValue, ::Ifc2x3::IfcCostValue* v8_CurrentValue, ::Ifc2x3::IfcCostValue* v9_TotalReplacementCost, ::Ifc2x3::IfcActorSelect* v10_Owner, ::Ifc2x3::IfcActorSelect* v11_User, ::Ifc2x3::IfcPerson* v12_ResponsiblePerson, ::Ifc2x3::IfcCalendarDate* v13_IncorporationDate, ::Ifc2x3::IfcCostValue* v14_DepreciatedValue) : IfcGroup(IfcEntityInstanceData(in_memory_attribute_storage(14))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (v6_AssetID));set_attribute_value(6, v7_OriginalValue ? v7_OriginalValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_CurrentValue ? v8_CurrentValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(8, v9_TotalReplacementCost ? v9_TotalReplacementCost->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(9, v10_Owner ? v10_Owner->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(10, v11_User ? v11_User->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(11, v12_ResponsiblePerson ? v12_ResponsiblePerson->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(12, v13_IncorporationDate ? v13_IncorporationDate->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(13, v14_DepreciatedValue ? v14_DepreciatedValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcAsymmetricIShapeProfileDef
double Ifc2x3::IfcAsymmetricIShapeProfileDef::TopFlangeWidth() const {  double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcAsymmetricIShapeProfileDef::setTopFlangeWidth(double v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
boost::optional< double > Ifc2x3::IfcAsymmetricIShapeProfileDef::TopFlangeThickness() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcAsymmetricIShapeProfileDef::setTopFlangeThickness(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
boost::optional< double > Ifc2x3::IfcAsymmetricIShapeProfileDef::TopFlangeFilletRadius() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcAsymmetricIShapeProfileDef::setTopFlangeFilletRadius(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
boost::optional< double > Ifc2x3::IfcAsymmetricIShapeProfileDef::CentreOfGravityInY() const { if(get_attribute_value(11).isNull()) { return boost::none; } double v = get_attribute_value(11); return v; }
void Ifc2x3::IfcAsymmetricIShapeProfileDef::setCentreOfGravityInY(boost::optional< double > v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }


const IfcParse::entity& Ifc2x3::IfcAsymmetricIShapeProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[51]); }
const IfcParse::entity& Ifc2x3::IfcAsymmetricIShapeProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[51]); }
Ifc2x3::IfcAsymmetricIShapeProfileDef::IfcAsymmetricIShapeProfileDef(IfcEntityInstanceData&& e) : IfcIShapeProfileDef(std::move(e)) { }
Ifc2x3::IfcAsymmetricIShapeProfileDef::IfcAsymmetricIShapeProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcAxis2Placement2D* v3_Position, double v4_OverallWidth, double v5_OverallDepth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius, double v9_TopFlangeWidth, boost::optional< double > v10_TopFlangeThickness, boost::optional< double > v11_TopFlangeFilletRadius, boost::optional< double > v12_CentreOfGravityInY) : IfcIShapeProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(12))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_OverallWidth));set_attribute_value(4, (v5_OverallDepth));set_attribute_value(5, (v6_WebThickness));set_attribute_value(6, (v7_FlangeThickness)); if (v8_FilletRadius) {set_attribute_value(7, (*v8_FilletRadius)); }set_attribute_value(8, (v9_TopFlangeWidth)); if (v10_TopFlangeThickness) {set_attribute_value(9, (*v10_TopFlangeThickness)); } if (v11_TopFlangeFilletRadius) {set_attribute_value(10, (*v11_TopFlangeFilletRadius)); } if (v12_CentreOfGravityInY) {set_attribute_value(11, (*v12_CentreOfGravityInY)); }; populate_derived(); }

// Function implementations for IfcAxis1Placement
::Ifc2x3::IfcDirection* Ifc2x3::IfcAxis1Placement::Axis() const { if(get_attribute_value(1).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcDirection>(true); }
void Ifc2x3::IfcAxis1Placement::setAxis(::Ifc2x3::IfcDirection* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcAxis1Placement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[52]); }
const IfcParse::entity& Ifc2x3::IfcAxis1Placement::Class() { return *((IfcParse::entity*)IFC2X3_types[52]); }
Ifc2x3::IfcAxis1Placement::IfcAxis1Placement(IfcEntityInstanceData&& e) : IfcPlacement(std::move(e)) { }
Ifc2x3::IfcAxis1Placement::IfcAxis1Placement(::Ifc2x3::IfcCartesianPoint* v1_Location, ::Ifc2x3::IfcDirection* v2_Axis) : IfcPlacement(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_Location ? v1_Location->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_Axis ? v2_Axis->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcAxis2Placement2D
::Ifc2x3::IfcDirection* Ifc2x3::IfcAxis2Placement2D::RefDirection() const { if(get_attribute_value(1).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcDirection>(true); }
void Ifc2x3::IfcAxis2Placement2D::setRefDirection(::Ifc2x3::IfcDirection* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcAxis2Placement2D::declaration() const { return *((IfcParse::entity*)IFC2X3_types[54]); }
const IfcParse::entity& Ifc2x3::IfcAxis2Placement2D::Class() { return *((IfcParse::entity*)IFC2X3_types[54]); }
Ifc2x3::IfcAxis2Placement2D::IfcAxis2Placement2D(IfcEntityInstanceData&& e) : IfcPlacement(std::move(e)) { }
Ifc2x3::IfcAxis2Placement2D::IfcAxis2Placement2D(::Ifc2x3::IfcCartesianPoint* v1_Location, ::Ifc2x3::IfcDirection* v2_RefDirection) : IfcPlacement(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_Location ? v1_Location->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_RefDirection ? v2_RefDirection->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcAxis2Placement3D
::Ifc2x3::IfcDirection* Ifc2x3::IfcAxis2Placement3D::Axis() const { if(get_attribute_value(1).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcDirection>(true); }
void Ifc2x3::IfcAxis2Placement3D::setAxis(::Ifc2x3::IfcDirection* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcDirection* Ifc2x3::IfcAxis2Placement3D::RefDirection() const { if(get_attribute_value(2).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcDirection>(true); }
void Ifc2x3::IfcAxis2Placement3D::setRefDirection(::Ifc2x3::IfcDirection* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcAxis2Placement3D::declaration() const { return *((IfcParse::entity*)IFC2X3_types[55]); }
const IfcParse::entity& Ifc2x3::IfcAxis2Placement3D::Class() { return *((IfcParse::entity*)IFC2X3_types[55]); }
Ifc2x3::IfcAxis2Placement3D::IfcAxis2Placement3D(IfcEntityInstanceData&& e) : IfcPlacement(std::move(e)) { }
Ifc2x3::IfcAxis2Placement3D::IfcAxis2Placement3D(::Ifc2x3::IfcCartesianPoint* v1_Location, ::Ifc2x3::IfcDirection* v2_Axis, ::Ifc2x3::IfcDirection* v3_RefDirection) : IfcPlacement(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_Location ? v1_Location->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_Axis ? v2_Axis->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_RefDirection ? v3_RefDirection->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcBSplineCurve
int Ifc2x3::IfcBSplineCurve::Degree() const {  int v = get_attribute_value(0); return v; }
void Ifc2x3::IfcBSplineCurve::setDegree(int v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcCartesianPoint >::ptr Ifc2x3::IfcBSplineCurve::ControlPointsList() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcCartesianPoint >(); }
void Ifc2x3::IfcBSplineCurve::setControlPointsList(aggregate_of< ::Ifc2x3::IfcCartesianPoint >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcBSplineCurveForm::Value Ifc2x3::IfcBSplineCurve::CurveForm() const {  return ::Ifc2x3::IfcBSplineCurveForm::FromString(get_attribute_value(2)); }
void Ifc2x3::IfcBSplineCurve::setCurveForm(::Ifc2x3::IfcBSplineCurveForm::Value v) { set_attribute_value(2, EnumerationReference(&::Ifc2x3::IfcBSplineCurveForm::Class(), (size_t) v));if constexpr (false)unset_attribute_value(2); }
boost::logic::tribool Ifc2x3::IfcBSplineCurve::ClosedCurve() const {  boost::logic::tribool v = get_attribute_value(3); return v; }
void Ifc2x3::IfcBSplineCurve::setClosedCurve(boost::logic::tribool v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
boost::logic::tribool Ifc2x3::IfcBSplineCurve::SelfIntersect() const {  boost::logic::tribool v = get_attribute_value(4); return v; }
void Ifc2x3::IfcBSplineCurve::setSelfIntersect(boost::logic::tribool v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcBSplineCurve::declaration() const { return *((IfcParse::entity*)IFC2X3_types[80]); }
const IfcParse::entity& Ifc2x3::IfcBSplineCurve::Class() { return *((IfcParse::entity*)IFC2X3_types[80]); }
Ifc2x3::IfcBSplineCurve::IfcBSplineCurve(IfcEntityInstanceData&& e) : IfcBoundedCurve(std::move(e)) { }
Ifc2x3::IfcBSplineCurve::IfcBSplineCurve(int v1_Degree, aggregate_of< ::Ifc2x3::IfcCartesianPoint >::ptr v2_ControlPointsList, ::Ifc2x3::IfcBSplineCurveForm::Value v3_CurveForm, boost::logic::tribool v4_ClosedCurve, boost::logic::tribool v5_SelfIntersect) : IfcBoundedCurve(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_Degree));set_attribute_value(1, (v2_ControlPointsList)->generalize());set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcBSplineCurveForm::Class(),(size_t)v3_CurveForm)));set_attribute_value(3, (v4_ClosedCurve));set_attribute_value(4, (v5_SelfIntersect));; populate_derived(); }

// Function implementations for IfcBeam


const IfcParse::entity& Ifc2x3::IfcBeam::declaration() const { return *((IfcParse::entity*)IFC2X3_types[56]); }
const IfcParse::entity& Ifc2x3::IfcBeam::Class() { return *((IfcParse::entity*)IFC2X3_types[56]); }
Ifc2x3::IfcBeam::IfcBeam(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcBeam::IfcBeam(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcBeamType
::Ifc2x3::IfcBeamTypeEnum::Value Ifc2x3::IfcBeamType::PredefinedType() const {  return ::Ifc2x3::IfcBeamTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcBeamType::setPredefinedType(::Ifc2x3::IfcBeamTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcBeamTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcBeamType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[57]); }
const IfcParse::entity& Ifc2x3::IfcBeamType::Class() { return *((IfcParse::entity*)IFC2X3_types[57]); }
Ifc2x3::IfcBeamType::IfcBeamType(IfcEntityInstanceData&& e) : IfcBuildingElementType(std::move(e)) { }
Ifc2x3::IfcBeamType::IfcBeamType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcBeamTypeEnum::Value v10_PredefinedType) : IfcBuildingElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcBeamTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcBezierCurve


const IfcParse::entity& Ifc2x3::IfcBezierCurve::declaration() const { return *((IfcParse::entity*)IFC2X3_types[60]); }
const IfcParse::entity& Ifc2x3::IfcBezierCurve::Class() { return *((IfcParse::entity*)IFC2X3_types[60]); }
Ifc2x3::IfcBezierCurve::IfcBezierCurve(IfcEntityInstanceData&& e) : IfcBSplineCurve(std::move(e)) { }
Ifc2x3::IfcBezierCurve::IfcBezierCurve(int v1_Degree, aggregate_of< ::Ifc2x3::IfcCartesianPoint >::ptr v2_ControlPointsList, ::Ifc2x3::IfcBSplineCurveForm::Value v3_CurveForm, boost::logic::tribool v4_ClosedCurve, boost::logic::tribool v5_SelfIntersect) : IfcBSplineCurve(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_Degree));set_attribute_value(1, (v2_ControlPointsList)->generalize());set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcBSplineCurveForm::Class(),(size_t)v3_CurveForm)));set_attribute_value(3, (v4_ClosedCurve));set_attribute_value(4, (v5_SelfIntersect));; populate_derived(); }

// Function implementations for IfcBlobTexture
std::string Ifc2x3::IfcBlobTexture::RasterFormat() const {  std::string v = get_attribute_value(4); return v; }
void Ifc2x3::IfcBlobTexture::setRasterFormat(std::string v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
bool Ifc2x3::IfcBlobTexture::RasterCode() const {  bool v = get_attribute_value(5); return v; }
void Ifc2x3::IfcBlobTexture::setRasterCode(bool v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcBlobTexture::declaration() const { return *((IfcParse::entity*)IFC2X3_types[61]); }
const IfcParse::entity& Ifc2x3::IfcBlobTexture::Class() { return *((IfcParse::entity*)IFC2X3_types[61]); }
Ifc2x3::IfcBlobTexture::IfcBlobTexture(IfcEntityInstanceData&& e) : IfcSurfaceTexture(std::move(e)) { }
Ifc2x3::IfcBlobTexture::IfcBlobTexture(bool v1_RepeatS, bool v2_RepeatT, ::Ifc2x3::IfcSurfaceTextureEnum::Value v3_TextureType, ::Ifc2x3::IfcCartesianTransformationOperator2D* v4_TextureTransform, std::string v5_RasterFormat, bool v6_RasterCode) : IfcSurfaceTexture(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_RepeatS));set_attribute_value(1, (v2_RepeatT));set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcSurfaceTextureEnum::Class(),(size_t)v3_TextureType)));set_attribute_value(3, v4_TextureTransform ? v4_TextureTransform->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(4, (v5_RasterFormat));set_attribute_value(5, (v6_RasterCode));; populate_derived(); }

// Function implementations for IfcBlock
double Ifc2x3::IfcBlock::XLength() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcBlock::setXLength(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
double Ifc2x3::IfcBlock::YLength() const {  double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcBlock::setYLength(double v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
double Ifc2x3::IfcBlock::ZLength() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcBlock::setZLength(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcBlock::declaration() const { return *((IfcParse::entity*)IFC2X3_types[62]); }
const IfcParse::entity& Ifc2x3::IfcBlock::Class() { return *((IfcParse::entity*)IFC2X3_types[62]); }
Ifc2x3::IfcBlock::IfcBlock(IfcEntityInstanceData&& e) : IfcCsgPrimitive3D(std::move(e)) { }
Ifc2x3::IfcBlock::IfcBlock(::Ifc2x3::IfcAxis2Placement3D* v1_Position, double v2_XLength, double v3_YLength, double v4_ZLength) : IfcCsgPrimitive3D(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_Position ? v1_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_XLength));set_attribute_value(2, (v3_YLength));set_attribute_value(3, (v4_ZLength));; populate_derived(); }

// Function implementations for IfcBoilerType
::Ifc2x3::IfcBoilerTypeEnum::Value Ifc2x3::IfcBoilerType::PredefinedType() const {  return ::Ifc2x3::IfcBoilerTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcBoilerType::setPredefinedType(::Ifc2x3::IfcBoilerTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcBoilerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcBoilerType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[63]); }
const IfcParse::entity& Ifc2x3::IfcBoilerType::Class() { return *((IfcParse::entity*)IFC2X3_types[63]); }
Ifc2x3::IfcBoilerType::IfcBoilerType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcBoilerType::IfcBoilerType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcBoilerTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcBoilerTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcBooleanClippingResult


const IfcParse::entity& Ifc2x3::IfcBooleanClippingResult::declaration() const { return *((IfcParse::entity*)IFC2X3_types[66]); }
const IfcParse::entity& Ifc2x3::IfcBooleanClippingResult::Class() { return *((IfcParse::entity*)IFC2X3_types[66]); }
Ifc2x3::IfcBooleanClippingResult::IfcBooleanClippingResult(IfcEntityInstanceData&& e) : IfcBooleanResult(std::move(e)) { }
Ifc2x3::IfcBooleanClippingResult::IfcBooleanClippingResult(::Ifc2x3::IfcBooleanOperator::Value v1_Operator, ::Ifc2x3::IfcBooleanOperand* v2_FirstOperand, ::Ifc2x3::IfcBooleanOperand* v3_SecondOperand) : IfcBooleanResult(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcBooleanOperator::Class(),(size_t)v1_Operator)));set_attribute_value(1, v2_FirstOperand ? v2_FirstOperand->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_SecondOperand ? v3_SecondOperand->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcBooleanResult
::Ifc2x3::IfcBooleanOperator::Value Ifc2x3::IfcBooleanResult::Operator() const {  return ::Ifc2x3::IfcBooleanOperator::FromString(get_attribute_value(0)); }
void Ifc2x3::IfcBooleanResult::setOperator(::Ifc2x3::IfcBooleanOperator::Value v) { set_attribute_value(0, EnumerationReference(&::Ifc2x3::IfcBooleanOperator::Class(), (size_t) v));if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcBooleanOperand* Ifc2x3::IfcBooleanResult::FirstOperand() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcBooleanOperand>(true); }
void Ifc2x3::IfcBooleanResult::setFirstOperand(::Ifc2x3::IfcBooleanOperand* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcBooleanOperand* Ifc2x3::IfcBooleanResult::SecondOperand() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcBooleanOperand>(true); }
void Ifc2x3::IfcBooleanResult::setSecondOperand(::Ifc2x3::IfcBooleanOperand* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcBooleanResult::declaration() const { return *((IfcParse::entity*)IFC2X3_types[69]); }
const IfcParse::entity& Ifc2x3::IfcBooleanResult::Class() { return *((IfcParse::entity*)IFC2X3_types[69]); }
Ifc2x3::IfcBooleanResult::IfcBooleanResult(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcBooleanResult::IfcBooleanResult(::Ifc2x3::IfcBooleanOperator::Value v1_Operator, ::Ifc2x3::IfcBooleanOperand* v2_FirstOperand, ::Ifc2x3::IfcBooleanOperand* v3_SecondOperand) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcBooleanOperator::Class(),(size_t)v1_Operator)));set_attribute_value(1, v2_FirstOperand ? v2_FirstOperand->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_SecondOperand ? v3_SecondOperand->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcBoundaryCondition
boost::optional< std::string > Ifc2x3::IfcBoundaryCondition::Name() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcBoundaryCondition::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }


const IfcParse::entity& Ifc2x3::IfcBoundaryCondition::declaration() const { return *((IfcParse::entity*)IFC2X3_types[70]); }
const IfcParse::entity& Ifc2x3::IfcBoundaryCondition::Class() { return *((IfcParse::entity*)IFC2X3_types[70]); }
Ifc2x3::IfcBoundaryCondition::IfcBoundaryCondition(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcBoundaryCondition::IfcBoundaryCondition(boost::optional< std::string > v1_Name) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }; populate_derived(); }

// Function implementations for IfcBoundaryEdgeCondition
boost::optional< double > Ifc2x3::IfcBoundaryEdgeCondition::LinearStiffnessByLengthX() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcBoundaryEdgeCondition::setLinearStiffnessByLengthX(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcBoundaryEdgeCondition::LinearStiffnessByLengthY() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcBoundaryEdgeCondition::setLinearStiffnessByLengthY(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcBoundaryEdgeCondition::LinearStiffnessByLengthZ() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcBoundaryEdgeCondition::setLinearStiffnessByLengthZ(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< double > Ifc2x3::IfcBoundaryEdgeCondition::RotationalStiffnessByLengthX() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthX(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< double > Ifc2x3::IfcBoundaryEdgeCondition::RotationalStiffnessByLengthY() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthY(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< double > Ifc2x3::IfcBoundaryEdgeCondition::RotationalStiffnessByLengthZ() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthZ(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }


const IfcParse::entity& Ifc2x3::IfcBoundaryEdgeCondition::declaration() const { return *((IfcParse::entity*)IFC2X3_types[71]); }
const IfcParse::entity& Ifc2x3::IfcBoundaryEdgeCondition::Class() { return *((IfcParse::entity*)IFC2X3_types[71]); }
Ifc2x3::IfcBoundaryEdgeCondition::IfcBoundaryEdgeCondition(IfcEntityInstanceData&& e) : IfcBoundaryCondition(std::move(e)) { }
Ifc2x3::IfcBoundaryEdgeCondition::IfcBoundaryEdgeCondition(boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearStiffnessByLengthX, boost::optional< double > v3_LinearStiffnessByLengthY, boost::optional< double > v4_LinearStiffnessByLengthZ, boost::optional< double > v5_RotationalStiffnessByLengthX, boost::optional< double > v6_RotationalStiffnessByLengthY, boost::optional< double > v7_RotationalStiffnessByLengthZ) : IfcBoundaryCondition(IfcEntityInstanceData(in_memory_attribute_storage(7))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_LinearStiffnessByLengthX) {set_attribute_value(1, (*v2_LinearStiffnessByLengthX)); } if (v3_LinearStiffnessByLengthY) {set_attribute_value(2, (*v3_LinearStiffnessByLengthY)); } if (v4_LinearStiffnessByLengthZ) {set_attribute_value(3, (*v4_LinearStiffnessByLengthZ)); } if (v5_RotationalStiffnessByLengthX) {set_attribute_value(4, (*v5_RotationalStiffnessByLengthX)); } if (v6_RotationalStiffnessByLengthY) {set_attribute_value(5, (*v6_RotationalStiffnessByLengthY)); } if (v7_RotationalStiffnessByLengthZ) {set_attribute_value(6, (*v7_RotationalStiffnessByLengthZ)); }; populate_derived(); }

// Function implementations for IfcBoundaryFaceCondition
boost::optional< double > Ifc2x3::IfcBoundaryFaceCondition::LinearStiffnessByAreaX() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcBoundaryFaceCondition::setLinearStiffnessByAreaX(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcBoundaryFaceCondition::LinearStiffnessByAreaY() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcBoundaryFaceCondition::setLinearStiffnessByAreaY(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcBoundaryFaceCondition::LinearStiffnessByAreaZ() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcBoundaryFaceCondition::setLinearStiffnessByAreaZ(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }


const IfcParse::entity& Ifc2x3::IfcBoundaryFaceCondition::declaration() const { return *((IfcParse::entity*)IFC2X3_types[72]); }
const IfcParse::entity& Ifc2x3::IfcBoundaryFaceCondition::Class() { return *((IfcParse::entity*)IFC2X3_types[72]); }
Ifc2x3::IfcBoundaryFaceCondition::IfcBoundaryFaceCondition(IfcEntityInstanceData&& e) : IfcBoundaryCondition(std::move(e)) { }
Ifc2x3::IfcBoundaryFaceCondition::IfcBoundaryFaceCondition(boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearStiffnessByAreaX, boost::optional< double > v3_LinearStiffnessByAreaY, boost::optional< double > v4_LinearStiffnessByAreaZ) : IfcBoundaryCondition(IfcEntityInstanceData(in_memory_attribute_storage(4))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_LinearStiffnessByAreaX) {set_attribute_value(1, (*v2_LinearStiffnessByAreaX)); } if (v3_LinearStiffnessByAreaY) {set_attribute_value(2, (*v3_LinearStiffnessByAreaY)); } if (v4_LinearStiffnessByAreaZ) {set_attribute_value(3, (*v4_LinearStiffnessByAreaZ)); }; populate_derived(); }

// Function implementations for IfcBoundaryNodeCondition
boost::optional< double > Ifc2x3::IfcBoundaryNodeCondition::LinearStiffnessX() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcBoundaryNodeCondition::setLinearStiffnessX(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcBoundaryNodeCondition::LinearStiffnessY() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcBoundaryNodeCondition::setLinearStiffnessY(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcBoundaryNodeCondition::LinearStiffnessZ() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcBoundaryNodeCondition::setLinearStiffnessZ(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< double > Ifc2x3::IfcBoundaryNodeCondition::RotationalStiffnessX() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcBoundaryNodeCondition::setRotationalStiffnessX(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< double > Ifc2x3::IfcBoundaryNodeCondition::RotationalStiffnessY() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcBoundaryNodeCondition::setRotationalStiffnessY(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< double > Ifc2x3::IfcBoundaryNodeCondition::RotationalStiffnessZ() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcBoundaryNodeCondition::setRotationalStiffnessZ(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }


const IfcParse::entity& Ifc2x3::IfcBoundaryNodeCondition::declaration() const { return *((IfcParse::entity*)IFC2X3_types[73]); }
const IfcParse::entity& Ifc2x3::IfcBoundaryNodeCondition::Class() { return *((IfcParse::entity*)IFC2X3_types[73]); }
Ifc2x3::IfcBoundaryNodeCondition::IfcBoundaryNodeCondition(IfcEntityInstanceData&& e) : IfcBoundaryCondition(std::move(e)) { }
Ifc2x3::IfcBoundaryNodeCondition::IfcBoundaryNodeCondition(boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearStiffnessX, boost::optional< double > v3_LinearStiffnessY, boost::optional< double > v4_LinearStiffnessZ, boost::optional< double > v5_RotationalStiffnessX, boost::optional< double > v6_RotationalStiffnessY, boost::optional< double > v7_RotationalStiffnessZ) : IfcBoundaryCondition(IfcEntityInstanceData(in_memory_attribute_storage(7))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_LinearStiffnessX) {set_attribute_value(1, (*v2_LinearStiffnessX)); } if (v3_LinearStiffnessY) {set_attribute_value(2, (*v3_LinearStiffnessY)); } if (v4_LinearStiffnessZ) {set_attribute_value(3, (*v4_LinearStiffnessZ)); } if (v5_RotationalStiffnessX) {set_attribute_value(4, (*v5_RotationalStiffnessX)); } if (v6_RotationalStiffnessY) {set_attribute_value(5, (*v6_RotationalStiffnessY)); } if (v7_RotationalStiffnessZ) {set_attribute_value(6, (*v7_RotationalStiffnessZ)); }; populate_derived(); }

// Function implementations for IfcBoundaryNodeConditionWarping
boost::optional< double > Ifc2x3::IfcBoundaryNodeConditionWarping::WarpingStiffness() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcBoundaryNodeConditionWarping::setWarpingStiffness(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }


const IfcParse::entity& Ifc2x3::IfcBoundaryNodeConditionWarping::declaration() const { return *((IfcParse::entity*)IFC2X3_types[74]); }
const IfcParse::entity& Ifc2x3::IfcBoundaryNodeConditionWarping::Class() { return *((IfcParse::entity*)IFC2X3_types[74]); }
Ifc2x3::IfcBoundaryNodeConditionWarping::IfcBoundaryNodeConditionWarping(IfcEntityInstanceData&& e) : IfcBoundaryNodeCondition(std::move(e)) { }
Ifc2x3::IfcBoundaryNodeConditionWarping::IfcBoundaryNodeConditionWarping(boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearStiffnessX, boost::optional< double > v3_LinearStiffnessY, boost::optional< double > v4_LinearStiffnessZ, boost::optional< double > v5_RotationalStiffnessX, boost::optional< double > v6_RotationalStiffnessY, boost::optional< double > v7_RotationalStiffnessZ, boost::optional< double > v8_WarpingStiffness) : IfcBoundaryNodeCondition(IfcEntityInstanceData(in_memory_attribute_storage(8))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_LinearStiffnessX) {set_attribute_value(1, (*v2_LinearStiffnessX)); } if (v3_LinearStiffnessY) {set_attribute_value(2, (*v3_LinearStiffnessY)); } if (v4_LinearStiffnessZ) {set_attribute_value(3, (*v4_LinearStiffnessZ)); } if (v5_RotationalStiffnessX) {set_attribute_value(4, (*v5_RotationalStiffnessX)); } if (v6_RotationalStiffnessY) {set_attribute_value(5, (*v6_RotationalStiffnessY)); } if (v7_RotationalStiffnessZ) {set_attribute_value(6, (*v7_RotationalStiffnessZ)); } if (v8_WarpingStiffness) {set_attribute_value(7, (*v8_WarpingStiffness)); }; populate_derived(); }

// Function implementations for IfcBoundedCurve


const IfcParse::entity& Ifc2x3::IfcBoundedCurve::declaration() const { return *((IfcParse::entity*)IFC2X3_types[75]); }
const IfcParse::entity& Ifc2x3::IfcBoundedCurve::Class() { return *((IfcParse::entity*)IFC2X3_types[75]); }
Ifc2x3::IfcBoundedCurve::IfcBoundedCurve(IfcEntityInstanceData&& e) : IfcCurve(std::move(e)) { }
Ifc2x3::IfcBoundedCurve::IfcBoundedCurve() : IfcCurve(IfcEntityInstanceData(in_memory_attribute_storage(0))) { ; populate_derived(); }

// Function implementations for IfcBoundedSurface


const IfcParse::entity& Ifc2x3::IfcBoundedSurface::declaration() const { return *((IfcParse::entity*)IFC2X3_types[76]); }
const IfcParse::entity& Ifc2x3::IfcBoundedSurface::Class() { return *((IfcParse::entity*)IFC2X3_types[76]); }
Ifc2x3::IfcBoundedSurface::IfcBoundedSurface(IfcEntityInstanceData&& e) : IfcSurface(std::move(e)) { }
Ifc2x3::IfcBoundedSurface::IfcBoundedSurface() : IfcSurface(IfcEntityInstanceData(in_memory_attribute_storage(0))) { ; populate_derived(); }

// Function implementations for IfcBoundingBox
::Ifc2x3::IfcCartesianPoint* Ifc2x3::IfcBoundingBox::Corner() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcCartesianPoint>(true); }
void Ifc2x3::IfcBoundingBox::setCorner(::Ifc2x3::IfcCartesianPoint* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
double Ifc2x3::IfcBoundingBox::XDim() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcBoundingBox::setXDim(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
double Ifc2x3::IfcBoundingBox::YDim() const {  double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcBoundingBox::setYDim(double v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
double Ifc2x3::IfcBoundingBox::ZDim() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcBoundingBox::setZDim(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcBoundingBox::declaration() const { return *((IfcParse::entity*)IFC2X3_types[77]); }
const IfcParse::entity& Ifc2x3::IfcBoundingBox::Class() { return *((IfcParse::entity*)IFC2X3_types[77]); }
Ifc2x3::IfcBoundingBox::IfcBoundingBox(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcBoundingBox::IfcBoundingBox(::Ifc2x3::IfcCartesianPoint* v1_Corner, double v2_XDim, double v3_YDim, double v4_ZDim) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_Corner ? v1_Corner->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_XDim));set_attribute_value(2, (v3_YDim));set_attribute_value(3, (v4_ZDim));; populate_derived(); }

// Function implementations for IfcBoxedHalfSpace
::Ifc2x3::IfcBoundingBox* Ifc2x3::IfcBoxedHalfSpace::Enclosure() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcBoundingBox>(true); }
void Ifc2x3::IfcBoxedHalfSpace::setEnclosure(::Ifc2x3::IfcBoundingBox* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcBoxedHalfSpace::declaration() const { return *((IfcParse::entity*)IFC2X3_types[79]); }
const IfcParse::entity& Ifc2x3::IfcBoxedHalfSpace::Class() { return *((IfcParse::entity*)IFC2X3_types[79]); }
Ifc2x3::IfcBoxedHalfSpace::IfcBoxedHalfSpace(IfcEntityInstanceData&& e) : IfcHalfSpaceSolid(std::move(e)) { }
Ifc2x3::IfcBoxedHalfSpace::IfcBoxedHalfSpace(::Ifc2x3::IfcSurface* v1_BaseSurface, bool v2_AgreementFlag, ::Ifc2x3::IfcBoundingBox* v3_Enclosure) : IfcHalfSpaceSolid(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_BaseSurface ? v1_BaseSurface->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_AgreementFlag));set_attribute_value(2, v3_Enclosure ? v3_Enclosure->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcBuilding
boost::optional< double > Ifc2x3::IfcBuilding::ElevationOfRefHeight() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcBuilding::setElevationOfRefHeight(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
boost::optional< double > Ifc2x3::IfcBuilding::ElevationOfTerrain() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcBuilding::setElevationOfTerrain(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
::Ifc2x3::IfcPostalAddress* Ifc2x3::IfcBuilding::BuildingAddress() const { if(get_attribute_value(11).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(11)))->as<::Ifc2x3::IfcPostalAddress>(true); }
void Ifc2x3::IfcBuilding::setBuildingAddress(::Ifc2x3::IfcPostalAddress* v) { set_attribute_value(11, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(11); }


const IfcParse::entity& Ifc2x3::IfcBuilding::declaration() const { return *((IfcParse::entity*)IFC2X3_types[82]); }
const IfcParse::entity& Ifc2x3::IfcBuilding::Class() { return *((IfcParse::entity*)IFC2X3_types[82]); }
Ifc2x3::IfcBuilding::IfcBuilding(IfcEntityInstanceData&& e) : IfcSpatialStructureElement(std::move(e)) { }
Ifc2x3::IfcBuilding::IfcBuilding(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, ::Ifc2x3::IfcElementCompositionEnum::Value v9_CompositionType, boost::optional< double > v10_ElevationOfRefHeight, boost::optional< double > v11_ElevationOfTerrain, ::Ifc2x3::IfcPostalAddress* v12_BuildingAddress) : IfcSpatialStructureElement(IfcEntityInstanceData(in_memory_attribute_storage(12))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_LongName) {set_attribute_value(7, (*v8_LongName)); }set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcElementCompositionEnum::Class(),(size_t)v9_CompositionType))); if (v10_ElevationOfRefHeight) {set_attribute_value(9, (*v10_ElevationOfRefHeight)); } if (v11_ElevationOfTerrain) {set_attribute_value(10, (*v11_ElevationOfTerrain)); }set_attribute_value(11, v12_BuildingAddress ? v12_BuildingAddress->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcBuildingElement


const IfcParse::entity& Ifc2x3::IfcBuildingElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[83]); }
const IfcParse::entity& Ifc2x3::IfcBuildingElement::Class() { return *((IfcParse::entity*)IFC2X3_types[83]); }
Ifc2x3::IfcBuildingElement::IfcBuildingElement(IfcEntityInstanceData&& e) : IfcElement(std::move(e)) { }
Ifc2x3::IfcBuildingElement::IfcBuildingElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcBuildingElementComponent


const IfcParse::entity& Ifc2x3::IfcBuildingElementComponent::declaration() const { return *((IfcParse::entity*)IFC2X3_types[84]); }
const IfcParse::entity& Ifc2x3::IfcBuildingElementComponent::Class() { return *((IfcParse::entity*)IFC2X3_types[84]); }
Ifc2x3::IfcBuildingElementComponent::IfcBuildingElementComponent(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcBuildingElementComponent::IfcBuildingElementComponent(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcBuildingElementPart


const IfcParse::entity& Ifc2x3::IfcBuildingElementPart::declaration() const { return *((IfcParse::entity*)IFC2X3_types[85]); }
const IfcParse::entity& Ifc2x3::IfcBuildingElementPart::Class() { return *((IfcParse::entity*)IFC2X3_types[85]); }
Ifc2x3::IfcBuildingElementPart::IfcBuildingElementPart(IfcEntityInstanceData&& e) : IfcBuildingElementComponent(std::move(e)) { }
Ifc2x3::IfcBuildingElementPart::IfcBuildingElementPart(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElementComponent(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcBuildingElementProxy
boost::optional< ::Ifc2x3::IfcElementCompositionEnum::Value > Ifc2x3::IfcBuildingElementProxy::CompositionType() const { if(get_attribute_value(8).isNull()) { return boost::none; } return ::Ifc2x3::IfcElementCompositionEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcBuildingElementProxy::setCompositionType(boost::optional< ::Ifc2x3::IfcElementCompositionEnum::Value > v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcElementCompositionEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }


const IfcParse::entity& Ifc2x3::IfcBuildingElementProxy::declaration() const { return *((IfcParse::entity*)IFC2X3_types[86]); }
const IfcParse::entity& Ifc2x3::IfcBuildingElementProxy::Class() { return *((IfcParse::entity*)IFC2X3_types[86]); }
Ifc2x3::IfcBuildingElementProxy::IfcBuildingElementProxy(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcBuildingElementProxy::IfcBuildingElementProxy(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< ::Ifc2x3::IfcElementCompositionEnum::Value > v9_CompositionType) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_CompositionType) {set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcElementCompositionEnum::Class(),(size_t)*v9_CompositionType))); }; populate_derived(); }

// Function implementations for IfcBuildingElementProxyType
::Ifc2x3::IfcBuildingElementProxyTypeEnum::Value Ifc2x3::IfcBuildingElementProxyType::PredefinedType() const {  return ::Ifc2x3::IfcBuildingElementProxyTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcBuildingElementProxyType::setPredefinedType(::Ifc2x3::IfcBuildingElementProxyTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcBuildingElementProxyTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcBuildingElementProxyType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[87]); }
const IfcParse::entity& Ifc2x3::IfcBuildingElementProxyType::Class() { return *((IfcParse::entity*)IFC2X3_types[87]); }
Ifc2x3::IfcBuildingElementProxyType::IfcBuildingElementProxyType(IfcEntityInstanceData&& e) : IfcBuildingElementType(std::move(e)) { }
Ifc2x3::IfcBuildingElementProxyType::IfcBuildingElementProxyType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcBuildingElementProxyTypeEnum::Value v10_PredefinedType) : IfcBuildingElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcBuildingElementProxyTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcBuildingElementType


const IfcParse::entity& Ifc2x3::IfcBuildingElementType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[89]); }
const IfcParse::entity& Ifc2x3::IfcBuildingElementType::Class() { return *((IfcParse::entity*)IFC2X3_types[89]); }
Ifc2x3::IfcBuildingElementType::IfcBuildingElementType(IfcEntityInstanceData&& e) : IfcElementType(std::move(e)) { }
Ifc2x3::IfcBuildingElementType::IfcBuildingElementType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcBuildingStorey
boost::optional< double > Ifc2x3::IfcBuildingStorey::Elevation() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcBuildingStorey::setElevation(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }


const IfcParse::entity& Ifc2x3::IfcBuildingStorey::declaration() const { return *((IfcParse::entity*)IFC2X3_types[90]); }
const IfcParse::entity& Ifc2x3::IfcBuildingStorey::Class() { return *((IfcParse::entity*)IFC2X3_types[90]); }
Ifc2x3::IfcBuildingStorey::IfcBuildingStorey(IfcEntityInstanceData&& e) : IfcSpatialStructureElement(std::move(e)) { }
Ifc2x3::IfcBuildingStorey::IfcBuildingStorey(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, ::Ifc2x3::IfcElementCompositionEnum::Value v9_CompositionType, boost::optional< double > v10_Elevation) : IfcSpatialStructureElement(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_LongName) {set_attribute_value(7, (*v8_LongName)); }set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcElementCompositionEnum::Class(),(size_t)v9_CompositionType))); if (v10_Elevation) {set_attribute_value(9, (*v10_Elevation)); }; populate_derived(); }

// Function implementations for IfcCShapeProfileDef
double Ifc2x3::IfcCShapeProfileDef::Depth() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcCShapeProfileDef::setDepth(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
double Ifc2x3::IfcCShapeProfileDef::Width() const {  double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcCShapeProfileDef::setWidth(double v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
double Ifc2x3::IfcCShapeProfileDef::WallThickness() const {  double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcCShapeProfileDef::setWallThickness(double v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
double Ifc2x3::IfcCShapeProfileDef::Girth() const {  double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcCShapeProfileDef::setGirth(double v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
boost::optional< double > Ifc2x3::IfcCShapeProfileDef::InternalFilletRadius() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcCShapeProfileDef::setInternalFilletRadius(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
boost::optional< double > Ifc2x3::IfcCShapeProfileDef::CentreOfGravityInX() const { if(get_attribute_value(8).isNull()) { return boost::none; } double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcCShapeProfileDef::setCentreOfGravityInX(boost::optional< double > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }


const IfcParse::entity& Ifc2x3::IfcCShapeProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[186]); }
const IfcParse::entity& Ifc2x3::IfcCShapeProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[186]); }
Ifc2x3::IfcCShapeProfileDef::IfcCShapeProfileDef(IfcEntityInstanceData&& e) : IfcParameterizedProfileDef(std::move(e)) { }
Ifc2x3::IfcCShapeProfileDef::IfcCShapeProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcAxis2Placement2D* v3_Position, double v4_Depth, double v5_Width, double v6_WallThickness, double v7_Girth, boost::optional< double > v8_InternalFilletRadius, boost::optional< double > v9_CentreOfGravityInX) : IfcParameterizedProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_Depth));set_attribute_value(4, (v5_Width));set_attribute_value(5, (v6_WallThickness));set_attribute_value(6, (v7_Girth)); if (v8_InternalFilletRadius) {set_attribute_value(7, (*v8_InternalFilletRadius)); } if (v9_CentreOfGravityInX) {set_attribute_value(8, (*v9_CentreOfGravityInX)); }; populate_derived(); }

// Function implementations for IfcCableCarrierFittingType
::Ifc2x3::IfcCableCarrierFittingTypeEnum::Value Ifc2x3::IfcCableCarrierFittingType::PredefinedType() const {  return ::Ifc2x3::IfcCableCarrierFittingTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcCableCarrierFittingType::setPredefinedType(::Ifc2x3::IfcCableCarrierFittingTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcCableCarrierFittingTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcCableCarrierFittingType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[91]); }
const IfcParse::entity& Ifc2x3::IfcCableCarrierFittingType::Class() { return *((IfcParse::entity*)IFC2X3_types[91]); }
Ifc2x3::IfcCableCarrierFittingType::IfcCableCarrierFittingType(IfcEntityInstanceData&& e) : IfcFlowFittingType(std::move(e)) { }
Ifc2x3::IfcCableCarrierFittingType::IfcCableCarrierFittingType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcCableCarrierFittingTypeEnum::Value v10_PredefinedType) : IfcFlowFittingType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcCableCarrierFittingTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcCableCarrierSegmentType
::Ifc2x3::IfcCableCarrierSegmentTypeEnum::Value Ifc2x3::IfcCableCarrierSegmentType::PredefinedType() const {  return ::Ifc2x3::IfcCableCarrierSegmentTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcCableCarrierSegmentType::setPredefinedType(::Ifc2x3::IfcCableCarrierSegmentTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcCableCarrierSegmentTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcCableCarrierSegmentType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[93]); }
const IfcParse::entity& Ifc2x3::IfcCableCarrierSegmentType::Class() { return *((IfcParse::entity*)IFC2X3_types[93]); }
Ifc2x3::IfcCableCarrierSegmentType::IfcCableCarrierSegmentType(IfcEntityInstanceData&& e) : IfcFlowSegmentType(std::move(e)) { }
Ifc2x3::IfcCableCarrierSegmentType::IfcCableCarrierSegmentType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcCableCarrierSegmentTypeEnum::Value v10_PredefinedType) : IfcFlowSegmentType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcCableCarrierSegmentTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcCableSegmentType
::Ifc2x3::IfcCableSegmentTypeEnum::Value Ifc2x3::IfcCableSegmentType::PredefinedType() const {  return ::Ifc2x3::IfcCableSegmentTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcCableSegmentType::setPredefinedType(::Ifc2x3::IfcCableSegmentTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcCableSegmentTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcCableSegmentType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[95]); }
const IfcParse::entity& Ifc2x3::IfcCableSegmentType::Class() { return *((IfcParse::entity*)IFC2X3_types[95]); }
Ifc2x3::IfcCableSegmentType::IfcCableSegmentType(IfcEntityInstanceData&& e) : IfcFlowSegmentType(std::move(e)) { }
Ifc2x3::IfcCableSegmentType::IfcCableSegmentType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcCableSegmentTypeEnum::Value v10_PredefinedType) : IfcFlowSegmentType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcCableSegmentTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcCalendarDate
int Ifc2x3::IfcCalendarDate::DayComponent() const {  int v = get_attribute_value(0); return v; }
void Ifc2x3::IfcCalendarDate::setDayComponent(int v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
int Ifc2x3::IfcCalendarDate::MonthComponent() const {  int v = get_attribute_value(1); return v; }
void Ifc2x3::IfcCalendarDate::setMonthComponent(int v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
int Ifc2x3::IfcCalendarDate::YearComponent() const {  int v = get_attribute_value(2); return v; }
void Ifc2x3::IfcCalendarDate::setYearComponent(int v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcCalendarDate::declaration() const { return *((IfcParse::entity*)IFC2X3_types[97]); }
const IfcParse::entity& Ifc2x3::IfcCalendarDate::Class() { return *((IfcParse::entity*)IFC2X3_types[97]); }
Ifc2x3::IfcCalendarDate::IfcCalendarDate(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcCalendarDate::IfcCalendarDate(int v1_DayComponent, int v2_MonthComponent, int v3_YearComponent) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, (v1_DayComponent));set_attribute_value(1, (v2_MonthComponent));set_attribute_value(2, (v3_YearComponent));; populate_derived(); }

// Function implementations for IfcCartesianPoint
std::vector< double > /*[1:3]*/ Ifc2x3::IfcCartesianPoint::Coordinates() const {  std::vector< double > /*[1:3]*/ v = get_attribute_value(0); return v; }
void Ifc2x3::IfcCartesianPoint::setCoordinates(std::vector< double > /*[1:3]*/ v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcCartesianPoint::declaration() const { return *((IfcParse::entity*)IFC2X3_types[98]); }
const IfcParse::entity& Ifc2x3::IfcCartesianPoint::Class() { return *((IfcParse::entity*)IFC2X3_types[98]); }
Ifc2x3::IfcCartesianPoint::IfcCartesianPoint(IfcEntityInstanceData&& e) : IfcPoint(std::move(e)) { }
Ifc2x3::IfcCartesianPoint::IfcCartesianPoint(std::vector< double > /*[1:3]*/ v1_Coordinates) : IfcPoint(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Coordinates));; populate_derived(); }

// Function implementations for IfcCartesianTransformationOperator
::Ifc2x3::IfcDirection* Ifc2x3::IfcCartesianTransformationOperator::Axis1() const { if(get_attribute_value(0).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcDirection>(true); }
void Ifc2x3::IfcCartesianTransformationOperator::setAxis1(::Ifc2x3::IfcDirection* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcDirection* Ifc2x3::IfcCartesianTransformationOperator::Axis2() const { if(get_attribute_value(1).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcDirection>(true); }
void Ifc2x3::IfcCartesianTransformationOperator::setAxis2(::Ifc2x3::IfcDirection* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcCartesianPoint* Ifc2x3::IfcCartesianTransformationOperator::LocalOrigin() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcCartesianPoint>(true); }
void Ifc2x3::IfcCartesianTransformationOperator::setLocalOrigin(::Ifc2x3::IfcCartesianPoint* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
boost::optional< double > Ifc2x3::IfcCartesianTransformationOperator::Scale() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcCartesianTransformationOperator::setScale(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }


const IfcParse::entity& Ifc2x3::IfcCartesianTransformationOperator::declaration() const { return *((IfcParse::entity*)IFC2X3_types[99]); }
const IfcParse::entity& Ifc2x3::IfcCartesianTransformationOperator::Class() { return *((IfcParse::entity*)IFC2X3_types[99]); }
Ifc2x3::IfcCartesianTransformationOperator::IfcCartesianTransformationOperator(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcCartesianTransformationOperator::IfcCartesianTransformationOperator(::Ifc2x3::IfcDirection* v1_Axis1, ::Ifc2x3::IfcDirection* v2_Axis2, ::Ifc2x3::IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_Axis1 ? v1_Axis1->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_Axis2 ? v2_Axis2->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_LocalOrigin ? v3_LocalOrigin->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v4_Scale) {set_attribute_value(3, (*v4_Scale)); }; populate_derived(); }

// Function implementations for IfcCartesianTransformationOperator2D


const IfcParse::entity& Ifc2x3::IfcCartesianTransformationOperator2D::declaration() const { return *((IfcParse::entity*)IFC2X3_types[100]); }
const IfcParse::entity& Ifc2x3::IfcCartesianTransformationOperator2D::Class() { return *((IfcParse::entity*)IFC2X3_types[100]); }
Ifc2x3::IfcCartesianTransformationOperator2D::IfcCartesianTransformationOperator2D(IfcEntityInstanceData&& e) : IfcCartesianTransformationOperator(std::move(e)) { }
Ifc2x3::IfcCartesianTransformationOperator2D::IfcCartesianTransformationOperator2D(::Ifc2x3::IfcDirection* v1_Axis1, ::Ifc2x3::IfcDirection* v2_Axis2, ::Ifc2x3::IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale) : IfcCartesianTransformationOperator(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_Axis1 ? v1_Axis1->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_Axis2 ? v2_Axis2->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_LocalOrigin ? v3_LocalOrigin->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v4_Scale) {set_attribute_value(3, (*v4_Scale)); }; populate_derived(); }

// Function implementations for IfcCartesianTransformationOperator2DnonUniform
boost::optional< double > Ifc2x3::IfcCartesianTransformationOperator2DnonUniform::Scale2() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcCartesianTransformationOperator2DnonUniform::setScale2(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }


const IfcParse::entity& Ifc2x3::IfcCartesianTransformationOperator2DnonUniform::declaration() const { return *((IfcParse::entity*)IFC2X3_types[101]); }
const IfcParse::entity& Ifc2x3::IfcCartesianTransformationOperator2DnonUniform::Class() { return *((IfcParse::entity*)IFC2X3_types[101]); }
Ifc2x3::IfcCartesianTransformationOperator2DnonUniform::IfcCartesianTransformationOperator2DnonUniform(IfcEntityInstanceData&& e) : IfcCartesianTransformationOperator2D(std::move(e)) { }
Ifc2x3::IfcCartesianTransformationOperator2DnonUniform::IfcCartesianTransformationOperator2DnonUniform(::Ifc2x3::IfcDirection* v1_Axis1, ::Ifc2x3::IfcDirection* v2_Axis2, ::Ifc2x3::IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale, boost::optional< double > v5_Scale2) : IfcCartesianTransformationOperator2D(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, v1_Axis1 ? v1_Axis1->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_Axis2 ? v2_Axis2->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_LocalOrigin ? v3_LocalOrigin->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v4_Scale) {set_attribute_value(3, (*v4_Scale)); } if (v5_Scale2) {set_attribute_value(4, (*v5_Scale2)); }; populate_derived(); }

// Function implementations for IfcCartesianTransformationOperator3D
::Ifc2x3::IfcDirection* Ifc2x3::IfcCartesianTransformationOperator3D::Axis3() const { if(get_attribute_value(4).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcDirection>(true); }
void Ifc2x3::IfcCartesianTransformationOperator3D::setAxis3(::Ifc2x3::IfcDirection* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcCartesianTransformationOperator3D::declaration() const { return *((IfcParse::entity*)IFC2X3_types[102]); }
const IfcParse::entity& Ifc2x3::IfcCartesianTransformationOperator3D::Class() { return *((IfcParse::entity*)IFC2X3_types[102]); }
Ifc2x3::IfcCartesianTransformationOperator3D::IfcCartesianTransformationOperator3D(IfcEntityInstanceData&& e) : IfcCartesianTransformationOperator(std::move(e)) { }
Ifc2x3::IfcCartesianTransformationOperator3D::IfcCartesianTransformationOperator3D(::Ifc2x3::IfcDirection* v1_Axis1, ::Ifc2x3::IfcDirection* v2_Axis2, ::Ifc2x3::IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale, ::Ifc2x3::IfcDirection* v5_Axis3) : IfcCartesianTransformationOperator(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, v1_Axis1 ? v1_Axis1->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_Axis2 ? v2_Axis2->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_LocalOrigin ? v3_LocalOrigin->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v4_Scale) {set_attribute_value(3, (*v4_Scale)); }set_attribute_value(4, v5_Axis3 ? v5_Axis3->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcCartesianTransformationOperator3DnonUniform
boost::optional< double > Ifc2x3::IfcCartesianTransformationOperator3DnonUniform::Scale2() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcCartesianTransformationOperator3DnonUniform::setScale2(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< double > Ifc2x3::IfcCartesianTransformationOperator3DnonUniform::Scale3() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcCartesianTransformationOperator3DnonUniform::setScale3(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }


const IfcParse::entity& Ifc2x3::IfcCartesianTransformationOperator3DnonUniform::declaration() const { return *((IfcParse::entity*)IFC2X3_types[103]); }
const IfcParse::entity& Ifc2x3::IfcCartesianTransformationOperator3DnonUniform::Class() { return *((IfcParse::entity*)IFC2X3_types[103]); }
Ifc2x3::IfcCartesianTransformationOperator3DnonUniform::IfcCartesianTransformationOperator3DnonUniform(IfcEntityInstanceData&& e) : IfcCartesianTransformationOperator3D(std::move(e)) { }
Ifc2x3::IfcCartesianTransformationOperator3DnonUniform::IfcCartesianTransformationOperator3DnonUniform(::Ifc2x3::IfcDirection* v1_Axis1, ::Ifc2x3::IfcDirection* v2_Axis2, ::Ifc2x3::IfcCartesianPoint* v3_LocalOrigin, boost::optional< double > v4_Scale, ::Ifc2x3::IfcDirection* v5_Axis3, boost::optional< double > v6_Scale2, boost::optional< double > v7_Scale3) : IfcCartesianTransformationOperator3D(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, v1_Axis1 ? v1_Axis1->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_Axis2 ? v2_Axis2->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_LocalOrigin ? v3_LocalOrigin->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v4_Scale) {set_attribute_value(3, (*v4_Scale)); }set_attribute_value(4, v5_Axis3 ? v5_Axis3->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v6_Scale2) {set_attribute_value(5, (*v6_Scale2)); } if (v7_Scale3) {set_attribute_value(6, (*v7_Scale3)); }; populate_derived(); }

// Function implementations for IfcCenterLineProfileDef
double Ifc2x3::IfcCenterLineProfileDef::Thickness() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcCenterLineProfileDef::setThickness(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcCenterLineProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[104]); }
const IfcParse::entity& Ifc2x3::IfcCenterLineProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[104]); }
Ifc2x3::IfcCenterLineProfileDef::IfcCenterLineProfileDef(IfcEntityInstanceData&& e) : IfcArbitraryOpenProfileDef(std::move(e)) { }
Ifc2x3::IfcCenterLineProfileDef::IfcCenterLineProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcBoundedCurve* v3_Curve, double v4_Thickness) : IfcArbitraryOpenProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Curve ? v3_Curve->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_Thickness));; populate_derived(); }

// Function implementations for IfcChamferEdgeFeature
boost::optional< double > Ifc2x3::IfcChamferEdgeFeature::Width() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcChamferEdgeFeature::setWidth(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
boost::optional< double > Ifc2x3::IfcChamferEdgeFeature::Height() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcChamferEdgeFeature::setHeight(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }


const IfcParse::entity& Ifc2x3::IfcChamferEdgeFeature::declaration() const { return *((IfcParse::entity*)IFC2X3_types[105]); }
const IfcParse::entity& Ifc2x3::IfcChamferEdgeFeature::Class() { return *((IfcParse::entity*)IFC2X3_types[105]); }
Ifc2x3::IfcChamferEdgeFeature::IfcChamferEdgeFeature(IfcEntityInstanceData&& e) : IfcEdgeFeature(std::move(e)) { }
Ifc2x3::IfcChamferEdgeFeature::IfcChamferEdgeFeature(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_FeatureLength, boost::optional< double > v10_Width, boost::optional< double > v11_Height) : IfcEdgeFeature(IfcEntityInstanceData(in_memory_attribute_storage(11))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_FeatureLength) {set_attribute_value(8, (*v9_FeatureLength)); } if (v10_Width) {set_attribute_value(9, (*v10_Width)); } if (v11_Height) {set_attribute_value(10, (*v11_Height)); }; populate_derived(); }

// Function implementations for IfcChillerType
::Ifc2x3::IfcChillerTypeEnum::Value Ifc2x3::IfcChillerType::PredefinedType() const {  return ::Ifc2x3::IfcChillerTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcChillerType::setPredefinedType(::Ifc2x3::IfcChillerTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcChillerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcChillerType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[108]); }
const IfcParse::entity& Ifc2x3::IfcChillerType::Class() { return *((IfcParse::entity*)IFC2X3_types[108]); }
Ifc2x3::IfcChillerType::IfcChillerType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcChillerType::IfcChillerType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcChillerTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcChillerTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcCircle
double Ifc2x3::IfcCircle::Radius() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcCircle::setRadius(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcCircle::declaration() const { return *((IfcParse::entity*)IFC2X3_types[110]); }
const IfcParse::entity& Ifc2x3::IfcCircle::Class() { return *((IfcParse::entity*)IFC2X3_types[110]); }
Ifc2x3::IfcCircle::IfcCircle(IfcEntityInstanceData&& e) : IfcConic(std::move(e)) { }
Ifc2x3::IfcCircle::IfcCircle(::Ifc2x3::IfcAxis2Placement* v1_Position, double v2_Radius) : IfcConic(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_Position ? v1_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Radius));; populate_derived(); }

// Function implementations for IfcCircleHollowProfileDef
double Ifc2x3::IfcCircleHollowProfileDef::WallThickness() const {  double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcCircleHollowProfileDef::setWallThickness(double v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcCircleHollowProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[111]); }
const IfcParse::entity& Ifc2x3::IfcCircleHollowProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[111]); }
Ifc2x3::IfcCircleHollowProfileDef::IfcCircleHollowProfileDef(IfcEntityInstanceData&& e) : IfcCircleProfileDef(std::move(e)) { }
Ifc2x3::IfcCircleHollowProfileDef::IfcCircleHollowProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcAxis2Placement2D* v3_Position, double v4_Radius, double v5_WallThickness) : IfcCircleProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_Radius));set_attribute_value(4, (v5_WallThickness));; populate_derived(); }

// Function implementations for IfcCircleProfileDef
double Ifc2x3::IfcCircleProfileDef::Radius() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcCircleProfileDef::setRadius(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcCircleProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[112]); }
const IfcParse::entity& Ifc2x3::IfcCircleProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[112]); }
Ifc2x3::IfcCircleProfileDef::IfcCircleProfileDef(IfcEntityInstanceData&& e) : IfcParameterizedProfileDef(std::move(e)) { }
Ifc2x3::IfcCircleProfileDef::IfcCircleProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcAxis2Placement2D* v3_Position, double v4_Radius) : IfcParameterizedProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_Radius));; populate_derived(); }

// Function implementations for IfcClassification
std::string Ifc2x3::IfcClassification::Source() const {  std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcClassification::setSource(std::string v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
std::string Ifc2x3::IfcClassification::Edition() const {  std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcClassification::setEdition(std::string v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcCalendarDate* Ifc2x3::IfcClassification::EditionDate() const { if(get_attribute_value(2).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcCalendarDate>(true); }
void Ifc2x3::IfcClassification::setEditionDate(::Ifc2x3::IfcCalendarDate* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
std::string Ifc2x3::IfcClassification::Name() const {  std::string v = get_attribute_value(3); return v; }
void Ifc2x3::IfcClassification::setName(std::string v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }

::Ifc2x3::IfcClassificationItem::list::ptr Ifc2x3::IfcClassification::Contains() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[114], 1)->as<IfcClassificationItem>(); }

const IfcParse::entity& Ifc2x3::IfcClassification::declaration() const { return *((IfcParse::entity*)IFC2X3_types[113]); }
const IfcParse::entity& Ifc2x3::IfcClassification::Class() { return *((IfcParse::entity*)IFC2X3_types[113]); }
Ifc2x3::IfcClassification::IfcClassification(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcClassification::IfcClassification(std::string v1_Source, std::string v2_Edition, ::Ifc2x3::IfcCalendarDate* v3_EditionDate, std::string v4_Name) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_Source));set_attribute_value(1, (v2_Edition));set_attribute_value(2, v3_EditionDate ? v3_EditionDate->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_Name));; populate_derived(); }

// Function implementations for IfcClassificationItem
::Ifc2x3::IfcClassificationNotationFacet* Ifc2x3::IfcClassificationItem::Notation() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcClassificationNotationFacet>(true); }
void Ifc2x3::IfcClassificationItem::setNotation(::Ifc2x3::IfcClassificationNotationFacet* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcClassification* Ifc2x3::IfcClassificationItem::ItemOf() const { if(get_attribute_value(1).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcClassification>(true); }
void Ifc2x3::IfcClassificationItem::setItemOf(::Ifc2x3::IfcClassification* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
std::string Ifc2x3::IfcClassificationItem::Title() const {  std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcClassificationItem::setTitle(std::string v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }

::Ifc2x3::IfcClassificationItemRelationship::list::ptr Ifc2x3::IfcClassificationItem::IsClassifiedItemIn() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[115], 1)->as<IfcClassificationItemRelationship>(); }
::Ifc2x3::IfcClassificationItemRelationship::list::ptr Ifc2x3::IfcClassificationItem::IsClassifyingItemIn() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[115], 0)->as<IfcClassificationItemRelationship>(); }

const IfcParse::entity& Ifc2x3::IfcClassificationItem::declaration() const { return *((IfcParse::entity*)IFC2X3_types[114]); }
const IfcParse::entity& Ifc2x3::IfcClassificationItem::Class() { return *((IfcParse::entity*)IFC2X3_types[114]); }
Ifc2x3::IfcClassificationItem::IfcClassificationItem(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcClassificationItem::IfcClassificationItem(::Ifc2x3::IfcClassificationNotationFacet* v1_Notation, ::Ifc2x3::IfcClassification* v2_ItemOf, std::string v3_Title) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_Notation ? v1_Notation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_ItemOf ? v2_ItemOf->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, (v3_Title));; populate_derived(); }

// Function implementations for IfcClassificationItemRelationship
::Ifc2x3::IfcClassificationItem* Ifc2x3::IfcClassificationItemRelationship::RelatingItem() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcClassificationItem>(true); }
void Ifc2x3::IfcClassificationItemRelationship::setRelatingItem(::Ifc2x3::IfcClassificationItem* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcClassificationItem >::ptr Ifc2x3::IfcClassificationItemRelationship::RelatedItems() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcClassificationItem >(); }
void Ifc2x3::IfcClassificationItemRelationship::setRelatedItems(aggregate_of< ::Ifc2x3::IfcClassificationItem >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcClassificationItemRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[115]); }
const IfcParse::entity& Ifc2x3::IfcClassificationItemRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[115]); }
Ifc2x3::IfcClassificationItemRelationship::IfcClassificationItemRelationship(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcClassificationItemRelationship::IfcClassificationItemRelationship(::Ifc2x3::IfcClassificationItem* v1_RelatingItem, aggregate_of< ::Ifc2x3::IfcClassificationItem >::ptr v2_RelatedItems) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_RelatingItem ? v1_RelatingItem->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_RelatedItems)->generalize());; populate_derived(); }

// Function implementations for IfcClassificationNotation
aggregate_of< ::Ifc2x3::IfcClassificationNotationFacet >::ptr Ifc2x3::IfcClassificationNotation::NotationFacets() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcClassificationNotationFacet >(); }
void Ifc2x3::IfcClassificationNotation::setNotationFacets(aggregate_of< ::Ifc2x3::IfcClassificationNotationFacet >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcClassificationNotation::declaration() const { return *((IfcParse::entity*)IFC2X3_types[116]); }
const IfcParse::entity& Ifc2x3::IfcClassificationNotation::Class() { return *((IfcParse::entity*)IFC2X3_types[116]); }
Ifc2x3::IfcClassificationNotation::IfcClassificationNotation(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcClassificationNotation::IfcClassificationNotation(aggregate_of< ::Ifc2x3::IfcClassificationNotationFacet >::ptr v1_NotationFacets) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_NotationFacets)->generalize());; populate_derived(); }

// Function implementations for IfcClassificationNotationFacet
std::string Ifc2x3::IfcClassificationNotationFacet::NotationValue() const {  std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcClassificationNotationFacet::setNotationValue(std::string v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcClassificationNotationFacet::declaration() const { return *((IfcParse::entity*)IFC2X3_types[117]); }
const IfcParse::entity& Ifc2x3::IfcClassificationNotationFacet::Class() { return *((IfcParse::entity*)IFC2X3_types[117]); }
Ifc2x3::IfcClassificationNotationFacet::IfcClassificationNotationFacet(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcClassificationNotationFacet::IfcClassificationNotationFacet(std::string v1_NotationValue) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_NotationValue));; populate_derived(); }

// Function implementations for IfcClassificationReference
::Ifc2x3::IfcClassification* Ifc2x3::IfcClassificationReference::ReferencedSource() const { if(get_attribute_value(3).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcClassification>(true); }
void Ifc2x3::IfcClassificationReference::setReferencedSource(::Ifc2x3::IfcClassification* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcClassificationReference::declaration() const { return *((IfcParse::entity*)IFC2X3_types[119]); }
const IfcParse::entity& Ifc2x3::IfcClassificationReference::Class() { return *((IfcParse::entity*)IFC2X3_types[119]); }
Ifc2x3::IfcClassificationReference::IfcClassificationReference(IfcEntityInstanceData&& e) : IfcExternalReference(std::move(e)) { }
Ifc2x3::IfcClassificationReference::IfcClassificationReference(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name, ::Ifc2x3::IfcClassification* v4_ReferencedSource) : IfcExternalReference(IfcEntityInstanceData(in_memory_attribute_storage(4))) {  if (v1_Location) {set_attribute_value(0, (*v1_Location)); } if (v2_ItemReference) {set_attribute_value(1, (*v2_ItemReference)); } if (v3_Name) {set_attribute_value(2, (*v3_Name)); }set_attribute_value(3, v4_ReferencedSource ? v4_ReferencedSource->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcClosedShell


const IfcParse::entity& Ifc2x3::IfcClosedShell::declaration() const { return *((IfcParse::entity*)IFC2X3_types[120]); }
const IfcParse::entity& Ifc2x3::IfcClosedShell::Class() { return *((IfcParse::entity*)IFC2X3_types[120]); }
Ifc2x3::IfcClosedShell::IfcClosedShell(IfcEntityInstanceData&& e) : IfcConnectedFaceSet(std::move(e)) { }
Ifc2x3::IfcClosedShell::IfcClosedShell(aggregate_of< ::Ifc2x3::IfcFace >::ptr v1_CfsFaces) : IfcConnectedFaceSet(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_CfsFaces)->generalize());; populate_derived(); }

// Function implementations for IfcCoilType
::Ifc2x3::IfcCoilTypeEnum::Value Ifc2x3::IfcCoilType::PredefinedType() const {  return ::Ifc2x3::IfcCoilTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcCoilType::setPredefinedType(::Ifc2x3::IfcCoilTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcCoilTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcCoilType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[121]); }
const IfcParse::entity& Ifc2x3::IfcCoilType::Class() { return *((IfcParse::entity*)IFC2X3_types[121]); }
Ifc2x3::IfcCoilType::IfcCoilType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcCoilType::IfcCoilType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcCoilTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcCoilTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcColourRgb
double Ifc2x3::IfcColourRgb::Red() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcColourRgb::setRed(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
double Ifc2x3::IfcColourRgb::Green() const {  double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcColourRgb::setGreen(double v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
double Ifc2x3::IfcColourRgb::Blue() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcColourRgb::setBlue(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcColourRgb::declaration() const { return *((IfcParse::entity*)IFC2X3_types[125]); }
const IfcParse::entity& Ifc2x3::IfcColourRgb::Class() { return *((IfcParse::entity*)IFC2X3_types[125]); }
Ifc2x3::IfcColourRgb::IfcColourRgb(IfcEntityInstanceData&& e) : IfcColourSpecification(std::move(e)) { }
Ifc2x3::IfcColourRgb::IfcColourRgb(boost::optional< std::string > v1_Name, double v2_Red, double v3_Green, double v4_Blue) : IfcColourSpecification(IfcEntityInstanceData(in_memory_attribute_storage(4))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (v2_Red));set_attribute_value(2, (v3_Green));set_attribute_value(3, (v4_Blue));; populate_derived(); }

// Function implementations for IfcColourSpecification
boost::optional< std::string > Ifc2x3::IfcColourSpecification::Name() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcColourSpecification::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }


const IfcParse::entity& Ifc2x3::IfcColourSpecification::declaration() const { return *((IfcParse::entity*)IFC2X3_types[126]); }
const IfcParse::entity& Ifc2x3::IfcColourSpecification::Class() { return *((IfcParse::entity*)IFC2X3_types[126]); }
Ifc2x3::IfcColourSpecification::IfcColourSpecification(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcColourSpecification::IfcColourSpecification(boost::optional< std::string > v1_Name) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }; populate_derived(); }

// Function implementations for IfcColumn


const IfcParse::entity& Ifc2x3::IfcColumn::declaration() const { return *((IfcParse::entity*)IFC2X3_types[127]); }
const IfcParse::entity& Ifc2x3::IfcColumn::Class() { return *((IfcParse::entity*)IFC2X3_types[127]); }
Ifc2x3::IfcColumn::IfcColumn(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcColumn::IfcColumn(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcColumnType
::Ifc2x3::IfcColumnTypeEnum::Value Ifc2x3::IfcColumnType::PredefinedType() const {  return ::Ifc2x3::IfcColumnTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcColumnType::setPredefinedType(::Ifc2x3::IfcColumnTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcColumnTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcColumnType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[128]); }
const IfcParse::entity& Ifc2x3::IfcColumnType::Class() { return *((IfcParse::entity*)IFC2X3_types[128]); }
Ifc2x3::IfcColumnType::IfcColumnType(IfcEntityInstanceData&& e) : IfcBuildingElementType(std::move(e)) { }
Ifc2x3::IfcColumnType::IfcColumnType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcColumnTypeEnum::Value v10_PredefinedType) : IfcBuildingElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcColumnTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcComplexProperty
std::string Ifc2x3::IfcComplexProperty::UsageName() const {  std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcComplexProperty::setUsageName(std::string v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
aggregate_of< ::Ifc2x3::IfcProperty >::ptr Ifc2x3::IfcComplexProperty::HasProperties() const {  aggregate_of_instance::ptr es = get_attribute_value(3); return es->as< ::Ifc2x3::IfcProperty >(); }
void Ifc2x3::IfcComplexProperty::setHasProperties(aggregate_of< ::Ifc2x3::IfcProperty >::ptr v) { set_attribute_value(3, (v)->generalize());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcComplexProperty::declaration() const { return *((IfcParse::entity*)IFC2X3_types[131]); }
const IfcParse::entity& Ifc2x3::IfcComplexProperty::Class() { return *((IfcParse::entity*)IFC2X3_types[131]); }
Ifc2x3::IfcComplexProperty::IfcComplexProperty(IfcEntityInstanceData&& e) : IfcProperty(std::move(e)) { }
Ifc2x3::IfcComplexProperty::IfcComplexProperty(std::string v1_Name, boost::optional< std::string > v2_Description, std::string v3_UsageName, aggregate_of< ::Ifc2x3::IfcProperty >::ptr v4_HasProperties) : IfcProperty(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_UsageName));set_attribute_value(3, (v4_HasProperties)->generalize());; populate_derived(); }

// Function implementations for IfcCompositeCurve
aggregate_of< ::Ifc2x3::IfcCompositeCurveSegment >::ptr Ifc2x3::IfcCompositeCurve::Segments() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcCompositeCurveSegment >(); }
void Ifc2x3::IfcCompositeCurve::setSegments(aggregate_of< ::Ifc2x3::IfcCompositeCurveSegment >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }
boost::logic::tribool Ifc2x3::IfcCompositeCurve::SelfIntersect() const {  boost::logic::tribool v = get_attribute_value(1); return v; }
void Ifc2x3::IfcCompositeCurve::setSelfIntersect(boost::logic::tribool v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcCompositeCurve::declaration() const { return *((IfcParse::entity*)IFC2X3_types[132]); }
const IfcParse::entity& Ifc2x3::IfcCompositeCurve::Class() { return *((IfcParse::entity*)IFC2X3_types[132]); }
Ifc2x3::IfcCompositeCurve::IfcCompositeCurve(IfcEntityInstanceData&& e) : IfcBoundedCurve(std::move(e)) { }
Ifc2x3::IfcCompositeCurve::IfcCompositeCurve(aggregate_of< ::Ifc2x3::IfcCompositeCurveSegment >::ptr v1_Segments, boost::logic::tribool v2_SelfIntersect) : IfcBoundedCurve(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (v1_Segments)->generalize());set_attribute_value(1, (v2_SelfIntersect));; populate_derived(); }

// Function implementations for IfcCompositeCurveSegment
::Ifc2x3::IfcTransitionCode::Value Ifc2x3::IfcCompositeCurveSegment::Transition() const {  return ::Ifc2x3::IfcTransitionCode::FromString(get_attribute_value(0)); }
void Ifc2x3::IfcCompositeCurveSegment::setTransition(::Ifc2x3::IfcTransitionCode::Value v) { set_attribute_value(0, EnumerationReference(&::Ifc2x3::IfcTransitionCode::Class(), (size_t) v));if constexpr (false)unset_attribute_value(0); }
bool Ifc2x3::IfcCompositeCurveSegment::SameSense() const {  bool v = get_attribute_value(1); return v; }
void Ifc2x3::IfcCompositeCurveSegment::setSameSense(bool v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcCurve* Ifc2x3::IfcCompositeCurveSegment::ParentCurve() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcCurve>(true); }
void Ifc2x3::IfcCompositeCurveSegment::setParentCurve(::Ifc2x3::IfcCurve* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }

::Ifc2x3::IfcCompositeCurve::list::ptr Ifc2x3::IfcCompositeCurveSegment::UsingCurves() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[132], 0)->as<IfcCompositeCurve>(); }

const IfcParse::entity& Ifc2x3::IfcCompositeCurveSegment::declaration() const { return *((IfcParse::entity*)IFC2X3_types[133]); }
const IfcParse::entity& Ifc2x3::IfcCompositeCurveSegment::Class() { return *((IfcParse::entity*)IFC2X3_types[133]); }
Ifc2x3::IfcCompositeCurveSegment::IfcCompositeCurveSegment(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcCompositeCurveSegment::IfcCompositeCurveSegment(::Ifc2x3::IfcTransitionCode::Value v1_Transition, bool v2_SameSense, ::Ifc2x3::IfcCurve* v3_ParentCurve) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcTransitionCode::Class(),(size_t)v1_Transition)));set_attribute_value(1, (v2_SameSense));set_attribute_value(2, v3_ParentCurve ? v3_ParentCurve->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcCompositeProfileDef
aggregate_of< ::Ifc2x3::IfcProfileDef >::ptr Ifc2x3::IfcCompositeProfileDef::Profiles() const {  aggregate_of_instance::ptr es = get_attribute_value(2); return es->as< ::Ifc2x3::IfcProfileDef >(); }
void Ifc2x3::IfcCompositeProfileDef::setProfiles(aggregate_of< ::Ifc2x3::IfcProfileDef >::ptr v) { set_attribute_value(2, (v)->generalize());if constexpr (false)unset_attribute_value(2); }
boost::optional< std::string > Ifc2x3::IfcCompositeProfileDef::Label() const { if(get_attribute_value(3).isNull()) { return boost::none; } std::string v = get_attribute_value(3); return v; }
void Ifc2x3::IfcCompositeProfileDef::setLabel(boost::optional< std::string > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }


const IfcParse::entity& Ifc2x3::IfcCompositeProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[134]); }
const IfcParse::entity& Ifc2x3::IfcCompositeProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[134]); }
Ifc2x3::IfcCompositeProfileDef::IfcCompositeProfileDef(IfcEntityInstanceData&& e) : IfcProfileDef(std::move(e)) { }
Ifc2x3::IfcCompositeProfileDef::IfcCompositeProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, aggregate_of< ::Ifc2x3::IfcProfileDef >::ptr v3_Profiles, boost::optional< std::string > v4_Label) : IfcProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Profiles)->generalize()); if (v4_Label) {set_attribute_value(3, (*v4_Label)); }; populate_derived(); }

// Function implementations for IfcCompressorType
::Ifc2x3::IfcCompressorTypeEnum::Value Ifc2x3::IfcCompressorType::PredefinedType() const {  return ::Ifc2x3::IfcCompressorTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcCompressorType::setPredefinedType(::Ifc2x3::IfcCompressorTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcCompressorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcCompressorType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[136]); }
const IfcParse::entity& Ifc2x3::IfcCompressorType::Class() { return *((IfcParse::entity*)IFC2X3_types[136]); }
Ifc2x3::IfcCompressorType::IfcCompressorType(IfcEntityInstanceData&& e) : IfcFlowMovingDeviceType(std::move(e)) { }
Ifc2x3::IfcCompressorType::IfcCompressorType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcCompressorTypeEnum::Value v10_PredefinedType) : IfcFlowMovingDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcCompressorTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcCondenserType
::Ifc2x3::IfcCondenserTypeEnum::Value Ifc2x3::IfcCondenserType::PredefinedType() const {  return ::Ifc2x3::IfcCondenserTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcCondenserType::setPredefinedType(::Ifc2x3::IfcCondenserTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcCondenserTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcCondenserType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[138]); }
const IfcParse::entity& Ifc2x3::IfcCondenserType::Class() { return *((IfcParse::entity*)IFC2X3_types[138]); }
Ifc2x3::IfcCondenserType::IfcCondenserType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcCondenserType::IfcCondenserType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcCondenserTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcCondenserTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcCondition


const IfcParse::entity& Ifc2x3::IfcCondition::declaration() const { return *((IfcParse::entity*)IFC2X3_types[140]); }
const IfcParse::entity& Ifc2x3::IfcCondition::Class() { return *((IfcParse::entity*)IFC2X3_types[140]); }
Ifc2x3::IfcCondition::IfcCondition(IfcEntityInstanceData&& e) : IfcGroup(std::move(e)) { }
Ifc2x3::IfcCondition::IfcCondition(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcGroup(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }; populate_derived(); }

// Function implementations for IfcConditionCriterion
::Ifc2x3::IfcConditionCriterionSelect* Ifc2x3::IfcConditionCriterion::Criterion() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcConditionCriterionSelect>(true); }
void Ifc2x3::IfcConditionCriterion::setCriterion(::Ifc2x3::IfcConditionCriterionSelect* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcConditionCriterion::CriterionDateTime() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcConditionCriterion::setCriterionDateTime(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcConditionCriterion::declaration() const { return *((IfcParse::entity*)IFC2X3_types[141]); }
const IfcParse::entity& Ifc2x3::IfcConditionCriterion::Class() { return *((IfcParse::entity*)IFC2X3_types[141]); }
Ifc2x3::IfcConditionCriterion::IfcConditionCriterion(IfcEntityInstanceData&& e) : IfcControl(std::move(e)) { }
Ifc2x3::IfcConditionCriterion::IfcConditionCriterion(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcConditionCriterionSelect* v6_Criterion, ::Ifc2x3::IfcDateTimeSelect* v7_CriterionDateTime) : IfcControl(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_Criterion ? v6_Criterion->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_CriterionDateTime ? v7_CriterionDateTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcConic
::Ifc2x3::IfcAxis2Placement* Ifc2x3::IfcConic::Position() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcAxis2Placement>(true); }
void Ifc2x3::IfcConic::setPosition(::Ifc2x3::IfcAxis2Placement* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcConic::declaration() const { return *((IfcParse::entity*)IFC2X3_types[143]); }
const IfcParse::entity& Ifc2x3::IfcConic::Class() { return *((IfcParse::entity*)IFC2X3_types[143]); }
Ifc2x3::IfcConic::IfcConic(IfcEntityInstanceData&& e) : IfcCurve(std::move(e)) { }
Ifc2x3::IfcConic::IfcConic(::Ifc2x3::IfcAxis2Placement* v1_Position) : IfcCurve(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, v1_Position ? v1_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcConnectedFaceSet
aggregate_of< ::Ifc2x3::IfcFace >::ptr Ifc2x3::IfcConnectedFaceSet::CfsFaces() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcFace >(); }
void Ifc2x3::IfcConnectedFaceSet::setCfsFaces(aggregate_of< ::Ifc2x3::IfcFace >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcConnectedFaceSet::declaration() const { return *((IfcParse::entity*)IFC2X3_types[144]); }
const IfcParse::entity& Ifc2x3::IfcConnectedFaceSet::Class() { return *((IfcParse::entity*)IFC2X3_types[144]); }
Ifc2x3::IfcConnectedFaceSet::IfcConnectedFaceSet(IfcEntityInstanceData&& e) : IfcTopologicalRepresentationItem(std::move(e)) { }
Ifc2x3::IfcConnectedFaceSet::IfcConnectedFaceSet(aggregate_of< ::Ifc2x3::IfcFace >::ptr v1_CfsFaces) : IfcTopologicalRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_CfsFaces)->generalize());; populate_derived(); }

// Function implementations for IfcConnectionCurveGeometry
::Ifc2x3::IfcCurveOrEdgeCurve* Ifc2x3::IfcConnectionCurveGeometry::CurveOnRelatingElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcCurveOrEdgeCurve>(true); }
void Ifc2x3::IfcConnectionCurveGeometry::setCurveOnRelatingElement(::Ifc2x3::IfcCurveOrEdgeCurve* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcCurveOrEdgeCurve* Ifc2x3::IfcConnectionCurveGeometry::CurveOnRelatedElement() const { if(get_attribute_value(1).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcCurveOrEdgeCurve>(true); }
void Ifc2x3::IfcConnectionCurveGeometry::setCurveOnRelatedElement(::Ifc2x3::IfcCurveOrEdgeCurve* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcConnectionCurveGeometry::declaration() const { return *((IfcParse::entity*)IFC2X3_types[145]); }
const IfcParse::entity& Ifc2x3::IfcConnectionCurveGeometry::Class() { return *((IfcParse::entity*)IFC2X3_types[145]); }
Ifc2x3::IfcConnectionCurveGeometry::IfcConnectionCurveGeometry(IfcEntityInstanceData&& e) : IfcConnectionGeometry(std::move(e)) { }
Ifc2x3::IfcConnectionCurveGeometry::IfcConnectionCurveGeometry(::Ifc2x3::IfcCurveOrEdgeCurve* v1_CurveOnRelatingElement, ::Ifc2x3::IfcCurveOrEdgeCurve* v2_CurveOnRelatedElement) : IfcConnectionGeometry(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_CurveOnRelatingElement ? v1_CurveOnRelatingElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_CurveOnRelatedElement ? v2_CurveOnRelatedElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcConnectionGeometry


const IfcParse::entity& Ifc2x3::IfcConnectionGeometry::declaration() const { return *((IfcParse::entity*)IFC2X3_types[146]); }
const IfcParse::entity& Ifc2x3::IfcConnectionGeometry::Class() { return *((IfcParse::entity*)IFC2X3_types[146]); }
Ifc2x3::IfcConnectionGeometry::IfcConnectionGeometry(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcConnectionGeometry::IfcConnectionGeometry() : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(0))) { ; populate_derived(); }

// Function implementations for IfcConnectionPointEccentricity
boost::optional< double > Ifc2x3::IfcConnectionPointEccentricity::EccentricityInX() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcConnectionPointEccentricity::setEccentricityInX(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcConnectionPointEccentricity::EccentricityInY() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcConnectionPointEccentricity::setEccentricityInY(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< double > Ifc2x3::IfcConnectionPointEccentricity::EccentricityInZ() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcConnectionPointEccentricity::setEccentricityInZ(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }


const IfcParse::entity& Ifc2x3::IfcConnectionPointEccentricity::declaration() const { return *((IfcParse::entity*)IFC2X3_types[147]); }
const IfcParse::entity& Ifc2x3::IfcConnectionPointEccentricity::Class() { return *((IfcParse::entity*)IFC2X3_types[147]); }
Ifc2x3::IfcConnectionPointEccentricity::IfcConnectionPointEccentricity(IfcEntityInstanceData&& e) : IfcConnectionPointGeometry(std::move(e)) { }
Ifc2x3::IfcConnectionPointEccentricity::IfcConnectionPointEccentricity(::Ifc2x3::IfcPointOrVertexPoint* v1_PointOnRelatingElement, ::Ifc2x3::IfcPointOrVertexPoint* v2_PointOnRelatedElement, boost::optional< double > v3_EccentricityInX, boost::optional< double > v4_EccentricityInY, boost::optional< double > v5_EccentricityInZ) : IfcConnectionPointGeometry(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, v1_PointOnRelatingElement ? v1_PointOnRelatingElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_PointOnRelatedElement ? v2_PointOnRelatedElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_EccentricityInX) {set_attribute_value(2, (*v3_EccentricityInX)); } if (v4_EccentricityInY) {set_attribute_value(3, (*v4_EccentricityInY)); } if (v5_EccentricityInZ) {set_attribute_value(4, (*v5_EccentricityInZ)); }; populate_derived(); }

// Function implementations for IfcConnectionPointGeometry
::Ifc2x3::IfcPointOrVertexPoint* Ifc2x3::IfcConnectionPointGeometry::PointOnRelatingElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcPointOrVertexPoint>(true); }
void Ifc2x3::IfcConnectionPointGeometry::setPointOnRelatingElement(::Ifc2x3::IfcPointOrVertexPoint* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcPointOrVertexPoint* Ifc2x3::IfcConnectionPointGeometry::PointOnRelatedElement() const { if(get_attribute_value(1).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcPointOrVertexPoint>(true); }
void Ifc2x3::IfcConnectionPointGeometry::setPointOnRelatedElement(::Ifc2x3::IfcPointOrVertexPoint* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcConnectionPointGeometry::declaration() const { return *((IfcParse::entity*)IFC2X3_types[148]); }
const IfcParse::entity& Ifc2x3::IfcConnectionPointGeometry::Class() { return *((IfcParse::entity*)IFC2X3_types[148]); }
Ifc2x3::IfcConnectionPointGeometry::IfcConnectionPointGeometry(IfcEntityInstanceData&& e) : IfcConnectionGeometry(std::move(e)) { }
Ifc2x3::IfcConnectionPointGeometry::IfcConnectionPointGeometry(::Ifc2x3::IfcPointOrVertexPoint* v1_PointOnRelatingElement, ::Ifc2x3::IfcPointOrVertexPoint* v2_PointOnRelatedElement) : IfcConnectionGeometry(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_PointOnRelatingElement ? v1_PointOnRelatingElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_PointOnRelatedElement ? v2_PointOnRelatedElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcConnectionPortGeometry
::Ifc2x3::IfcAxis2Placement* Ifc2x3::IfcConnectionPortGeometry::LocationAtRelatingElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcAxis2Placement>(true); }
void Ifc2x3::IfcConnectionPortGeometry::setLocationAtRelatingElement(::Ifc2x3::IfcAxis2Placement* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcAxis2Placement* Ifc2x3::IfcConnectionPortGeometry::LocationAtRelatedElement() const { if(get_attribute_value(1).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcAxis2Placement>(true); }
void Ifc2x3::IfcConnectionPortGeometry::setLocationAtRelatedElement(::Ifc2x3::IfcAxis2Placement* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcProfileDef* Ifc2x3::IfcConnectionPortGeometry::ProfileOfPort() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcProfileDef>(true); }
void Ifc2x3::IfcConnectionPortGeometry::setProfileOfPort(::Ifc2x3::IfcProfileDef* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcConnectionPortGeometry::declaration() const { return *((IfcParse::entity*)IFC2X3_types[149]); }
const IfcParse::entity& Ifc2x3::IfcConnectionPortGeometry::Class() { return *((IfcParse::entity*)IFC2X3_types[149]); }
Ifc2x3::IfcConnectionPortGeometry::IfcConnectionPortGeometry(IfcEntityInstanceData&& e) : IfcConnectionGeometry(std::move(e)) { }
Ifc2x3::IfcConnectionPortGeometry::IfcConnectionPortGeometry(::Ifc2x3::IfcAxis2Placement* v1_LocationAtRelatingElement, ::Ifc2x3::IfcAxis2Placement* v2_LocationAtRelatedElement, ::Ifc2x3::IfcProfileDef* v3_ProfileOfPort) : IfcConnectionGeometry(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_LocationAtRelatingElement ? v1_LocationAtRelatingElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_LocationAtRelatedElement ? v2_LocationAtRelatedElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_ProfileOfPort ? v3_ProfileOfPort->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcConnectionSurfaceGeometry
::Ifc2x3::IfcSurfaceOrFaceSurface* Ifc2x3::IfcConnectionSurfaceGeometry::SurfaceOnRelatingElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcSurfaceOrFaceSurface>(true); }
void Ifc2x3::IfcConnectionSurfaceGeometry::setSurfaceOnRelatingElement(::Ifc2x3::IfcSurfaceOrFaceSurface* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcSurfaceOrFaceSurface* Ifc2x3::IfcConnectionSurfaceGeometry::SurfaceOnRelatedElement() const { if(get_attribute_value(1).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcSurfaceOrFaceSurface>(true); }
void Ifc2x3::IfcConnectionSurfaceGeometry::setSurfaceOnRelatedElement(::Ifc2x3::IfcSurfaceOrFaceSurface* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcConnectionSurfaceGeometry::declaration() const { return *((IfcParse::entity*)IFC2X3_types[150]); }
const IfcParse::entity& Ifc2x3::IfcConnectionSurfaceGeometry::Class() { return *((IfcParse::entity*)IFC2X3_types[150]); }
Ifc2x3::IfcConnectionSurfaceGeometry::IfcConnectionSurfaceGeometry(IfcEntityInstanceData&& e) : IfcConnectionGeometry(std::move(e)) { }
Ifc2x3::IfcConnectionSurfaceGeometry::IfcConnectionSurfaceGeometry(::Ifc2x3::IfcSurfaceOrFaceSurface* v1_SurfaceOnRelatingElement, ::Ifc2x3::IfcSurfaceOrFaceSurface* v2_SurfaceOnRelatedElement) : IfcConnectionGeometry(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_SurfaceOnRelatingElement ? v1_SurfaceOnRelatingElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_SurfaceOnRelatedElement ? v2_SurfaceOnRelatedElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcConstraint
std::string Ifc2x3::IfcConstraint::Name() const {  std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcConstraint::setName(std::string v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
boost::optional< std::string > Ifc2x3::IfcConstraint::Description() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcConstraint::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
::Ifc2x3::IfcConstraintEnum::Value Ifc2x3::IfcConstraint::ConstraintGrade() const {  return ::Ifc2x3::IfcConstraintEnum::FromString(get_attribute_value(2)); }
void Ifc2x3::IfcConstraint::setConstraintGrade(::Ifc2x3::IfcConstraintEnum::Value v) { set_attribute_value(2, EnumerationReference(&::Ifc2x3::IfcConstraintEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(2); }
boost::optional< std::string > Ifc2x3::IfcConstraint::ConstraintSource() const { if(get_attribute_value(3).isNull()) { return boost::none; } std::string v = get_attribute_value(3); return v; }
void Ifc2x3::IfcConstraint::setConstraintSource(boost::optional< std::string > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
::Ifc2x3::IfcActorSelect* Ifc2x3::IfcConstraint::CreatingActor() const { if(get_attribute_value(4).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcActorSelect>(true); }
void Ifc2x3::IfcConstraint::setCreatingActor(::Ifc2x3::IfcActorSelect* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcConstraint::CreationTime() const { if(get_attribute_value(5).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcConstraint::setCreationTime(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }
boost::optional< std::string > Ifc2x3::IfcConstraint::UserDefinedGrade() const { if(get_attribute_value(6).isNull()) { return boost::none; } std::string v = get_attribute_value(6); return v; }
void Ifc2x3::IfcConstraint::setUserDefinedGrade(boost::optional< std::string > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }

::Ifc2x3::IfcConstraintClassificationRelationship::list::ptr Ifc2x3::IfcConstraint::ClassifiedAs() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[154], 0)->as<IfcConstraintClassificationRelationship>(); }
::Ifc2x3::IfcConstraintRelationship::list::ptr Ifc2x3::IfcConstraint::RelatesConstraints() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[156], 2)->as<IfcConstraintRelationship>(); }
::Ifc2x3::IfcConstraintRelationship::list::ptr Ifc2x3::IfcConstraint::IsRelatedWith() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[156], 3)->as<IfcConstraintRelationship>(); }
::Ifc2x3::IfcPropertyConstraintRelationship::list::ptr Ifc2x3::IfcConstraint::PropertiesForConstraint() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[617], 0)->as<IfcPropertyConstraintRelationship>(); }
::Ifc2x3::IfcConstraintAggregationRelationship::list::ptr Ifc2x3::IfcConstraint::Aggregates() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[153], 2)->as<IfcConstraintAggregationRelationship>(); }
::Ifc2x3::IfcConstraintAggregationRelationship::list::ptr Ifc2x3::IfcConstraint::IsAggregatedIn() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[153], 3)->as<IfcConstraintAggregationRelationship>(); }

const IfcParse::entity& Ifc2x3::IfcConstraint::declaration() const { return *((IfcParse::entity*)IFC2X3_types[152]); }
const IfcParse::entity& Ifc2x3::IfcConstraint::Class() { return *((IfcParse::entity*)IFC2X3_types[152]); }
Ifc2x3::IfcConstraint::IfcConstraint(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcConstraint::IfcConstraint(std::string v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcConstraintEnum::Value v3_ConstraintGrade, boost::optional< std::string > v4_ConstraintSource, ::Ifc2x3::IfcActorSelect* v5_CreatingActor, ::Ifc2x3::IfcDateTimeSelect* v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcConstraintEnum::Class(),(size_t)v3_ConstraintGrade))); if (v4_ConstraintSource) {set_attribute_value(3, (*v4_ConstraintSource)); }set_attribute_value(4, v5_CreatingActor ? v5_CreatingActor->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_CreationTime ? v6_CreationTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v7_UserDefinedGrade) {set_attribute_value(6, (*v7_UserDefinedGrade)); }; populate_derived(); }

// Function implementations for IfcConstraintAggregationRelationship
boost::optional< std::string > Ifc2x3::IfcConstraintAggregationRelationship::Name() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcConstraintAggregationRelationship::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
boost::optional< std::string > Ifc2x3::IfcConstraintAggregationRelationship::Description() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcConstraintAggregationRelationship::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
::Ifc2x3::IfcConstraint* Ifc2x3::IfcConstraintAggregationRelationship::RelatingConstraint() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcConstraint>(true); }
void Ifc2x3::IfcConstraintAggregationRelationship::setRelatingConstraint(::Ifc2x3::IfcConstraint* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
aggregate_of< ::Ifc2x3::IfcConstraint >::ptr Ifc2x3::IfcConstraintAggregationRelationship::RelatedConstraints() const {  aggregate_of_instance::ptr es = get_attribute_value(3); return es->as< ::Ifc2x3::IfcConstraint >(); }
void Ifc2x3::IfcConstraintAggregationRelationship::setRelatedConstraints(aggregate_of< ::Ifc2x3::IfcConstraint >::ptr v) { set_attribute_value(3, (v)->generalize());if constexpr (false)unset_attribute_value(3); }
::Ifc2x3::IfcLogicalOperatorEnum::Value Ifc2x3::IfcConstraintAggregationRelationship::LogicalAggregator() const {  return ::Ifc2x3::IfcLogicalOperatorEnum::FromString(get_attribute_value(4)); }
void Ifc2x3::IfcConstraintAggregationRelationship::setLogicalAggregator(::Ifc2x3::IfcLogicalOperatorEnum::Value v) { set_attribute_value(4, EnumerationReference(&::Ifc2x3::IfcLogicalOperatorEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcConstraintAggregationRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[153]); }
const IfcParse::entity& Ifc2x3::IfcConstraintAggregationRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[153]); }
Ifc2x3::IfcConstraintAggregationRelationship::IfcConstraintAggregationRelationship(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcConstraintAggregationRelationship::IfcConstraintAggregationRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcConstraint* v3_RelatingConstraint, aggregate_of< ::Ifc2x3::IfcConstraint >::ptr v4_RelatedConstraints, ::Ifc2x3::IfcLogicalOperatorEnum::Value v5_LogicalAggregator) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(5))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_RelatingConstraint ? v3_RelatingConstraint->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_RelatedConstraints)->generalize());set_attribute_value(4, (EnumerationReference(&::Ifc2x3::IfcLogicalOperatorEnum::Class(),(size_t)v5_LogicalAggregator)));; populate_derived(); }

// Function implementations for IfcConstraintClassificationRelationship
::Ifc2x3::IfcConstraint* Ifc2x3::IfcConstraintClassificationRelationship::ClassifiedConstraint() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcConstraint>(true); }
void Ifc2x3::IfcConstraintClassificationRelationship::setClassifiedConstraint(::Ifc2x3::IfcConstraint* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcClassificationNotationSelect >::ptr Ifc2x3::IfcConstraintClassificationRelationship::RelatedClassifications() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcClassificationNotationSelect >(); }
void Ifc2x3::IfcConstraintClassificationRelationship::setRelatedClassifications(aggregate_of< ::Ifc2x3::IfcClassificationNotationSelect >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcConstraintClassificationRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[154]); }
const IfcParse::entity& Ifc2x3::IfcConstraintClassificationRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[154]); }
Ifc2x3::IfcConstraintClassificationRelationship::IfcConstraintClassificationRelationship(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcConstraintClassificationRelationship::IfcConstraintClassificationRelationship(::Ifc2x3::IfcConstraint* v1_ClassifiedConstraint, aggregate_of< ::Ifc2x3::IfcClassificationNotationSelect >::ptr v2_RelatedClassifications) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_ClassifiedConstraint ? v1_ClassifiedConstraint->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_RelatedClassifications)->generalize());; populate_derived(); }

// Function implementations for IfcConstraintRelationship
boost::optional< std::string > Ifc2x3::IfcConstraintRelationship::Name() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcConstraintRelationship::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
boost::optional< std::string > Ifc2x3::IfcConstraintRelationship::Description() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcConstraintRelationship::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
::Ifc2x3::IfcConstraint* Ifc2x3::IfcConstraintRelationship::RelatingConstraint() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcConstraint>(true); }
void Ifc2x3::IfcConstraintRelationship::setRelatingConstraint(::Ifc2x3::IfcConstraint* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
aggregate_of< ::Ifc2x3::IfcConstraint >::ptr Ifc2x3::IfcConstraintRelationship::RelatedConstraints() const {  aggregate_of_instance::ptr es = get_attribute_value(3); return es->as< ::Ifc2x3::IfcConstraint >(); }
void Ifc2x3::IfcConstraintRelationship::setRelatedConstraints(aggregate_of< ::Ifc2x3::IfcConstraint >::ptr v) { set_attribute_value(3, (v)->generalize());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcConstraintRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[156]); }
const IfcParse::entity& Ifc2x3::IfcConstraintRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[156]); }
Ifc2x3::IfcConstraintRelationship::IfcConstraintRelationship(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcConstraintRelationship::IfcConstraintRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcConstraint* v3_RelatingConstraint, aggregate_of< ::Ifc2x3::IfcConstraint >::ptr v4_RelatedConstraints) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(4))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_RelatingConstraint ? v3_RelatingConstraint->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_RelatedConstraints)->generalize());; populate_derived(); }

// Function implementations for IfcConstructionEquipmentResource


const IfcParse::entity& Ifc2x3::IfcConstructionEquipmentResource::declaration() const { return *((IfcParse::entity*)IFC2X3_types[157]); }
const IfcParse::entity& Ifc2x3::IfcConstructionEquipmentResource::Class() { return *((IfcParse::entity*)IFC2X3_types[157]); }
Ifc2x3::IfcConstructionEquipmentResource::IfcConstructionEquipmentResource(IfcEntityInstanceData&& e) : IfcConstructionResource(std::move(e)) { }
Ifc2x3::IfcConstructionEquipmentResource::IfcConstructionEquipmentResource(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< ::Ifc2x3::IfcResourceConsumptionEnum::Value > v8_ResourceConsumption, ::Ifc2x3::IfcMeasureWithUnit* v9_BaseQuantity) : IfcConstructionResource(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); } if (v6_ResourceIdentifier) {set_attribute_value(5, (*v6_ResourceIdentifier)); } if (v7_ResourceGroup) {set_attribute_value(6, (*v7_ResourceGroup)); } if (v8_ResourceConsumption) {set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcResourceConsumptionEnum::Class(),(size_t)*v8_ResourceConsumption))); }set_attribute_value(8, v9_BaseQuantity ? v9_BaseQuantity->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcConstructionMaterialResource
boost::optional< aggregate_of< ::Ifc2x3::IfcActorSelect >::ptr > Ifc2x3::IfcConstructionMaterialResource::Suppliers() const { if(get_attribute_value(9).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(9); return es->as< ::Ifc2x3::IfcActorSelect >(); }
void Ifc2x3::IfcConstructionMaterialResource::setSuppliers(boost::optional< aggregate_of< ::Ifc2x3::IfcActorSelect >::ptr > v) { if (v) {set_attribute_value(9, (*v)->generalize());} else {unset_attribute_value(9);} }
boost::optional< double > Ifc2x3::IfcConstructionMaterialResource::UsageRatio() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcConstructionMaterialResource::setUsageRatio(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }


const IfcParse::entity& Ifc2x3::IfcConstructionMaterialResource::declaration() const { return *((IfcParse::entity*)IFC2X3_types[158]); }
const IfcParse::entity& Ifc2x3::IfcConstructionMaterialResource::Class() { return *((IfcParse::entity*)IFC2X3_types[158]); }
Ifc2x3::IfcConstructionMaterialResource::IfcConstructionMaterialResource(IfcEntityInstanceData&& e) : IfcConstructionResource(std::move(e)) { }
Ifc2x3::IfcConstructionMaterialResource::IfcConstructionMaterialResource(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< ::Ifc2x3::IfcResourceConsumptionEnum::Value > v8_ResourceConsumption, ::Ifc2x3::IfcMeasureWithUnit* v9_BaseQuantity, boost::optional< aggregate_of< ::Ifc2x3::IfcActorSelect >::ptr > v10_Suppliers, boost::optional< double > v11_UsageRatio) : IfcConstructionResource(IfcEntityInstanceData(in_memory_attribute_storage(11))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); } if (v6_ResourceIdentifier) {set_attribute_value(5, (*v6_ResourceIdentifier)); } if (v7_ResourceGroup) {set_attribute_value(6, (*v7_ResourceGroup)); } if (v8_ResourceConsumption) {set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcResourceConsumptionEnum::Class(),(size_t)*v8_ResourceConsumption))); }set_attribute_value(8, v9_BaseQuantity ? v9_BaseQuantity->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v10_Suppliers) {set_attribute_value(9, (*v10_Suppliers)->generalize()); } if (v11_UsageRatio) {set_attribute_value(10, (*v11_UsageRatio)); }; populate_derived(); }

// Function implementations for IfcConstructionProductResource


const IfcParse::entity& Ifc2x3::IfcConstructionProductResource::declaration() const { return *((IfcParse::entity*)IFC2X3_types[159]); }
const IfcParse::entity& Ifc2x3::IfcConstructionProductResource::Class() { return *((IfcParse::entity*)IFC2X3_types[159]); }
Ifc2x3::IfcConstructionProductResource::IfcConstructionProductResource(IfcEntityInstanceData&& e) : IfcConstructionResource(std::move(e)) { }
Ifc2x3::IfcConstructionProductResource::IfcConstructionProductResource(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< ::Ifc2x3::IfcResourceConsumptionEnum::Value > v8_ResourceConsumption, ::Ifc2x3::IfcMeasureWithUnit* v9_BaseQuantity) : IfcConstructionResource(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); } if (v6_ResourceIdentifier) {set_attribute_value(5, (*v6_ResourceIdentifier)); } if (v7_ResourceGroup) {set_attribute_value(6, (*v7_ResourceGroup)); } if (v8_ResourceConsumption) {set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcResourceConsumptionEnum::Class(),(size_t)*v8_ResourceConsumption))); }set_attribute_value(8, v9_BaseQuantity ? v9_BaseQuantity->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcConstructionResource
boost::optional< std::string > Ifc2x3::IfcConstructionResource::ResourceIdentifier() const { if(get_attribute_value(5).isNull()) { return boost::none; } std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcConstructionResource::setResourceIdentifier(boost::optional< std::string > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< std::string > Ifc2x3::IfcConstructionResource::ResourceGroup() const { if(get_attribute_value(6).isNull()) { return boost::none; } std::string v = get_attribute_value(6); return v; }
void Ifc2x3::IfcConstructionResource::setResourceGroup(boost::optional< std::string > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
boost::optional< ::Ifc2x3::IfcResourceConsumptionEnum::Value > Ifc2x3::IfcConstructionResource::ResourceConsumption() const { if(get_attribute_value(7).isNull()) { return boost::none; } return ::Ifc2x3::IfcResourceConsumptionEnum::FromString(get_attribute_value(7)); }
void Ifc2x3::IfcConstructionResource::setResourceConsumption(boost::optional< ::Ifc2x3::IfcResourceConsumptionEnum::Value > v) { if (v) {set_attribute_value(7, EnumerationReference(&::Ifc2x3::IfcResourceConsumptionEnum::Class(), (size_t) *v));} else {unset_attribute_value(7);} }
::Ifc2x3::IfcMeasureWithUnit* Ifc2x3::IfcConstructionResource::BaseQuantity() const { if(get_attribute_value(8).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(8)))->as<::Ifc2x3::IfcMeasureWithUnit>(true); }
void Ifc2x3::IfcConstructionResource::setBaseQuantity(::Ifc2x3::IfcMeasureWithUnit* v) { set_attribute_value(8, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(8); }


const IfcParse::entity& Ifc2x3::IfcConstructionResource::declaration() const { return *((IfcParse::entity*)IFC2X3_types[160]); }
const IfcParse::entity& Ifc2x3::IfcConstructionResource::Class() { return *((IfcParse::entity*)IFC2X3_types[160]); }
Ifc2x3::IfcConstructionResource::IfcConstructionResource(IfcEntityInstanceData&& e) : IfcResource(std::move(e)) { }
Ifc2x3::IfcConstructionResource::IfcConstructionResource(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< ::Ifc2x3::IfcResourceConsumptionEnum::Value > v8_ResourceConsumption, ::Ifc2x3::IfcMeasureWithUnit* v9_BaseQuantity) : IfcResource(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); } if (v6_ResourceIdentifier) {set_attribute_value(5, (*v6_ResourceIdentifier)); } if (v7_ResourceGroup) {set_attribute_value(6, (*v7_ResourceGroup)); } if (v8_ResourceConsumption) {set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcResourceConsumptionEnum::Class(),(size_t)*v8_ResourceConsumption))); }set_attribute_value(8, v9_BaseQuantity ? v9_BaseQuantity->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcContextDependentUnit
std::string Ifc2x3::IfcContextDependentUnit::Name() const {  std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcContextDependentUnit::setName(std::string v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcContextDependentUnit::declaration() const { return *((IfcParse::entity*)IFC2X3_types[162]); }
const IfcParse::entity& Ifc2x3::IfcContextDependentUnit::Class() { return *((IfcParse::entity*)IFC2X3_types[162]); }
Ifc2x3::IfcContextDependentUnit::IfcContextDependentUnit(IfcEntityInstanceData&& e) : IfcNamedUnit(std::move(e)) { }
Ifc2x3::IfcContextDependentUnit::IfcContextDependentUnit(::Ifc2x3::IfcDimensionalExponents* v1_Dimensions, ::Ifc2x3::IfcUnitEnum::Value v2_UnitType, std::string v3_Name) : IfcNamedUnit(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_Dimensions ? v1_Dimensions->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (EnumerationReference(&::Ifc2x3::IfcUnitEnum::Class(),(size_t)v2_UnitType)));set_attribute_value(2, (v3_Name));; populate_derived(); }

// Function implementations for IfcControl

::Ifc2x3::IfcRelAssignsToControl::list::ptr Ifc2x3::IfcControl::Controls() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[671], 6)->as<IfcRelAssignsToControl>(); }

const IfcParse::entity& Ifc2x3::IfcControl::declaration() const { return *((IfcParse::entity*)IFC2X3_types[163]); }
const IfcParse::entity& Ifc2x3::IfcControl::Class() { return *((IfcParse::entity*)IFC2X3_types[163]); }
Ifc2x3::IfcControl::IfcControl(IfcEntityInstanceData&& e) : IfcObject(std::move(e)) { }
Ifc2x3::IfcControl::IfcControl(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcObject(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }; populate_derived(); }

// Function implementations for IfcControllerType
::Ifc2x3::IfcControllerTypeEnum::Value Ifc2x3::IfcControllerType::PredefinedType() const {  return ::Ifc2x3::IfcControllerTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcControllerType::setPredefinedType(::Ifc2x3::IfcControllerTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcControllerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcControllerType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[164]); }
const IfcParse::entity& Ifc2x3::IfcControllerType::Class() { return *((IfcParse::entity*)IFC2X3_types[164]); }
Ifc2x3::IfcControllerType::IfcControllerType(IfcEntityInstanceData&& e) : IfcDistributionControlElementType(std::move(e)) { }
Ifc2x3::IfcControllerType::IfcControllerType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcControllerTypeEnum::Value v10_PredefinedType) : IfcDistributionControlElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcControllerTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcConversionBasedUnit
std::string Ifc2x3::IfcConversionBasedUnit::Name() const {  std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcConversionBasedUnit::setName(std::string v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcMeasureWithUnit* Ifc2x3::IfcConversionBasedUnit::ConversionFactor() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcMeasureWithUnit>(true); }
void Ifc2x3::IfcConversionBasedUnit::setConversionFactor(::Ifc2x3::IfcMeasureWithUnit* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcConversionBasedUnit::declaration() const { return *((IfcParse::entity*)IFC2X3_types[166]); }
const IfcParse::entity& Ifc2x3::IfcConversionBasedUnit::Class() { return *((IfcParse::entity*)IFC2X3_types[166]); }
Ifc2x3::IfcConversionBasedUnit::IfcConversionBasedUnit(IfcEntityInstanceData&& e) : IfcNamedUnit(std::move(e)) { }
Ifc2x3::IfcConversionBasedUnit::IfcConversionBasedUnit(::Ifc2x3::IfcDimensionalExponents* v1_Dimensions, ::Ifc2x3::IfcUnitEnum::Value v2_UnitType, std::string v3_Name, ::Ifc2x3::IfcMeasureWithUnit* v4_ConversionFactor) : IfcNamedUnit(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_Dimensions ? v1_Dimensions->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (EnumerationReference(&::Ifc2x3::IfcUnitEnum::Class(),(size_t)v2_UnitType)));set_attribute_value(2, (v3_Name));set_attribute_value(3, v4_ConversionFactor ? v4_ConversionFactor->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcCooledBeamType
::Ifc2x3::IfcCooledBeamTypeEnum::Value Ifc2x3::IfcCooledBeamType::PredefinedType() const {  return ::Ifc2x3::IfcCooledBeamTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcCooledBeamType::setPredefinedType(::Ifc2x3::IfcCooledBeamTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcCooledBeamTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcCooledBeamType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[167]); }
const IfcParse::entity& Ifc2x3::IfcCooledBeamType::Class() { return *((IfcParse::entity*)IFC2X3_types[167]); }
Ifc2x3::IfcCooledBeamType::IfcCooledBeamType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcCooledBeamType::IfcCooledBeamType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcCooledBeamTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcCooledBeamTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcCoolingTowerType
::Ifc2x3::IfcCoolingTowerTypeEnum::Value Ifc2x3::IfcCoolingTowerType::PredefinedType() const {  return ::Ifc2x3::IfcCoolingTowerTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcCoolingTowerType::setPredefinedType(::Ifc2x3::IfcCoolingTowerTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcCoolingTowerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcCoolingTowerType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[169]); }
const IfcParse::entity& Ifc2x3::IfcCoolingTowerType::Class() { return *((IfcParse::entity*)IFC2X3_types[169]); }
Ifc2x3::IfcCoolingTowerType::IfcCoolingTowerType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcCoolingTowerType::IfcCoolingTowerType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcCoolingTowerTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcCoolingTowerTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcCoordinatedUniversalTimeOffset
int Ifc2x3::IfcCoordinatedUniversalTimeOffset::HourOffset() const {  int v = get_attribute_value(0); return v; }
void Ifc2x3::IfcCoordinatedUniversalTimeOffset::setHourOffset(int v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
boost::optional< int > Ifc2x3::IfcCoordinatedUniversalTimeOffset::MinuteOffset() const { if(get_attribute_value(1).isNull()) { return boost::none; } int v = get_attribute_value(1); return v; }
void Ifc2x3::IfcCoordinatedUniversalTimeOffset::setMinuteOffset(boost::optional< int > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
::Ifc2x3::IfcAheadOrBehind::Value Ifc2x3::IfcCoordinatedUniversalTimeOffset::Sense() const {  return ::Ifc2x3::IfcAheadOrBehind::FromString(get_attribute_value(2)); }
void Ifc2x3::IfcCoordinatedUniversalTimeOffset::setSense(::Ifc2x3::IfcAheadOrBehind::Value v) { set_attribute_value(2, EnumerationReference(&::Ifc2x3::IfcAheadOrBehind::Class(), (size_t) v));if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcCoordinatedUniversalTimeOffset::declaration() const { return *((IfcParse::entity*)IFC2X3_types[171]); }
const IfcParse::entity& Ifc2x3::IfcCoordinatedUniversalTimeOffset::Class() { return *((IfcParse::entity*)IFC2X3_types[171]); }
Ifc2x3::IfcCoordinatedUniversalTimeOffset::IfcCoordinatedUniversalTimeOffset(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcCoordinatedUniversalTimeOffset::IfcCoordinatedUniversalTimeOffset(int v1_HourOffset, boost::optional< int > v2_MinuteOffset, ::Ifc2x3::IfcAheadOrBehind::Value v3_Sense) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, (v1_HourOffset)); if (v2_MinuteOffset) {set_attribute_value(1, (*v2_MinuteOffset)); }set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcAheadOrBehind::Class(),(size_t)v3_Sense)));; populate_derived(); }

// Function implementations for IfcCostItem


const IfcParse::entity& Ifc2x3::IfcCostItem::declaration() const { return *((IfcParse::entity*)IFC2X3_types[172]); }
const IfcParse::entity& Ifc2x3::IfcCostItem::Class() { return *((IfcParse::entity*)IFC2X3_types[172]); }
Ifc2x3::IfcCostItem::IfcCostItem(IfcEntityInstanceData&& e) : IfcControl(std::move(e)) { }
Ifc2x3::IfcCostItem::IfcCostItem(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcControl(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }; populate_derived(); }

// Function implementations for IfcCostSchedule
::Ifc2x3::IfcActorSelect* Ifc2x3::IfcCostSchedule::SubmittedBy() const { if(get_attribute_value(5).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcActorSelect>(true); }
void Ifc2x3::IfcCostSchedule::setSubmittedBy(::Ifc2x3::IfcActorSelect* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcActorSelect* Ifc2x3::IfcCostSchedule::PreparedBy() const { if(get_attribute_value(6).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcActorSelect>(true); }
void Ifc2x3::IfcCostSchedule::setPreparedBy(::Ifc2x3::IfcActorSelect* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcCostSchedule::SubmittedOn() const { if(get_attribute_value(7).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(7)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcCostSchedule::setSubmittedOn(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(7, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(7); }
boost::optional< std::string > Ifc2x3::IfcCostSchedule::Status() const { if(get_attribute_value(8).isNull()) { return boost::none; } std::string v = get_attribute_value(8); return v; }
void Ifc2x3::IfcCostSchedule::setStatus(boost::optional< std::string > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
boost::optional< aggregate_of< ::Ifc2x3::IfcActorSelect >::ptr > Ifc2x3::IfcCostSchedule::TargetUsers() const { if(get_attribute_value(9).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(9); return es->as< ::Ifc2x3::IfcActorSelect >(); }
void Ifc2x3::IfcCostSchedule::setTargetUsers(boost::optional< aggregate_of< ::Ifc2x3::IfcActorSelect >::ptr > v) { if (v) {set_attribute_value(9, (*v)->generalize());} else {unset_attribute_value(9);} }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcCostSchedule::UpdateDate() const { if(get_attribute_value(10).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(10)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcCostSchedule::setUpdateDate(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(10, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(10); }
std::string Ifc2x3::IfcCostSchedule::ID() const {  std::string v = get_attribute_value(11); return v; }
void Ifc2x3::IfcCostSchedule::setID(std::string v) { set_attribute_value(11, v);if constexpr (false)unset_attribute_value(11); }
::Ifc2x3::IfcCostScheduleTypeEnum::Value Ifc2x3::IfcCostSchedule::PredefinedType() const {  return ::Ifc2x3::IfcCostScheduleTypeEnum::FromString(get_attribute_value(12)); }
void Ifc2x3::IfcCostSchedule::setPredefinedType(::Ifc2x3::IfcCostScheduleTypeEnum::Value v) { set_attribute_value(12, EnumerationReference(&::Ifc2x3::IfcCostScheduleTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(12); }


const IfcParse::entity& Ifc2x3::IfcCostSchedule::declaration() const { return *((IfcParse::entity*)IFC2X3_types[173]); }
const IfcParse::entity& Ifc2x3::IfcCostSchedule::Class() { return *((IfcParse::entity*)IFC2X3_types[173]); }
Ifc2x3::IfcCostSchedule::IfcCostSchedule(IfcEntityInstanceData&& e) : IfcControl(std::move(e)) { }
Ifc2x3::IfcCostSchedule::IfcCostSchedule(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcActorSelect* v6_SubmittedBy, ::Ifc2x3::IfcActorSelect* v7_PreparedBy, ::Ifc2x3::IfcDateTimeSelect* v8_SubmittedOn, boost::optional< std::string > v9_Status, boost::optional< aggregate_of< ::Ifc2x3::IfcActorSelect >::ptr > v10_TargetUsers, ::Ifc2x3::IfcDateTimeSelect* v11_UpdateDate, std::string v12_ID, ::Ifc2x3::IfcCostScheduleTypeEnum::Value v13_PredefinedType) : IfcControl(IfcEntityInstanceData(in_memory_attribute_storage(13))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_SubmittedBy ? v6_SubmittedBy->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_PreparedBy ? v7_PreparedBy->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_SubmittedOn ? v8_SubmittedOn->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v9_Status) {set_attribute_value(8, (*v9_Status)); } if (v10_TargetUsers) {set_attribute_value(9, (*v10_TargetUsers)->generalize()); }set_attribute_value(10, v11_UpdateDate ? v11_UpdateDate->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(11, (v12_ID));set_attribute_value(12, (EnumerationReference(&::Ifc2x3::IfcCostScheduleTypeEnum::Class(),(size_t)v13_PredefinedType)));; populate_derived(); }

// Function implementations for IfcCostValue
std::string Ifc2x3::IfcCostValue::CostType() const {  std::string v = get_attribute_value(6); return v; }
void Ifc2x3::IfcCostValue::setCostType(std::string v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
boost::optional< std::string > Ifc2x3::IfcCostValue::Condition() const { if(get_attribute_value(7).isNull()) { return boost::none; } std::string v = get_attribute_value(7); return v; }
void Ifc2x3::IfcCostValue::setCondition(boost::optional< std::string > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }


const IfcParse::entity& Ifc2x3::IfcCostValue::declaration() const { return *((IfcParse::entity*)IFC2X3_types[175]); }
const IfcParse::entity& Ifc2x3::IfcCostValue::Class() { return *((IfcParse::entity*)IFC2X3_types[175]); }
Ifc2x3::IfcCostValue::IfcCostValue(IfcEntityInstanceData&& e) : IfcAppliedValue(std::move(e)) { }
Ifc2x3::IfcCostValue::IfcCostValue(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcAppliedValueSelect* v3_AppliedValue, ::Ifc2x3::IfcMeasureWithUnit* v4_UnitBasis, ::Ifc2x3::IfcDateTimeSelect* v5_ApplicableDate, ::Ifc2x3::IfcDateTimeSelect* v6_FixedUntilDate, std::string v7_CostType, boost::optional< std::string > v8_Condition) : IfcAppliedValue(IfcEntityInstanceData(in_memory_attribute_storage(8))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_AppliedValue ? v3_AppliedValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_UnitBasis ? v4_UnitBasis->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(4, v5_ApplicableDate ? v5_ApplicableDate->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_FixedUntilDate ? v6_FixedUntilDate->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, (v7_CostType)); if (v8_Condition) {set_attribute_value(7, (*v8_Condition)); }; populate_derived(); }

// Function implementations for IfcCovering
boost::optional< ::Ifc2x3::IfcCoveringTypeEnum::Value > Ifc2x3::IfcCovering::PredefinedType() const { if(get_attribute_value(8).isNull()) { return boost::none; } return ::Ifc2x3::IfcCoveringTypeEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcCovering::setPredefinedType(boost::optional< ::Ifc2x3::IfcCoveringTypeEnum::Value > v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcCoveringTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }

::Ifc2x3::IfcRelCoversSpaces::list::ptr Ifc2x3::IfcCovering::CoversSpaces() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[700], 5)->as<IfcRelCoversSpaces>(); }
::Ifc2x3::IfcRelCoversBldgElements::list::ptr Ifc2x3::IfcCovering::Covers() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[699], 5)->as<IfcRelCoversBldgElements>(); }

const IfcParse::entity& Ifc2x3::IfcCovering::declaration() const { return *((IfcParse::entity*)IFC2X3_types[177]); }
const IfcParse::entity& Ifc2x3::IfcCovering::Class() { return *((IfcParse::entity*)IFC2X3_types[177]); }
Ifc2x3::IfcCovering::IfcCovering(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcCovering::IfcCovering(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< ::Ifc2x3::IfcCoveringTypeEnum::Value > v9_PredefinedType) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcCoveringTypeEnum::Class(),(size_t)*v9_PredefinedType))); }; populate_derived(); }

// Function implementations for IfcCoveringType
::Ifc2x3::IfcCoveringTypeEnum::Value Ifc2x3::IfcCoveringType::PredefinedType() const {  return ::Ifc2x3::IfcCoveringTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcCoveringType::setPredefinedType(::Ifc2x3::IfcCoveringTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcCoveringTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcCoveringType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[178]); }
const IfcParse::entity& Ifc2x3::IfcCoveringType::Class() { return *((IfcParse::entity*)IFC2X3_types[178]); }
Ifc2x3::IfcCoveringType::IfcCoveringType(IfcEntityInstanceData&& e) : IfcBuildingElementType(std::move(e)) { }
Ifc2x3::IfcCoveringType::IfcCoveringType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcCoveringTypeEnum::Value v10_PredefinedType) : IfcBuildingElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcCoveringTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcCraneRailAShapeProfileDef
double Ifc2x3::IfcCraneRailAShapeProfileDef::OverallHeight() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcCraneRailAShapeProfileDef::setOverallHeight(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
double Ifc2x3::IfcCraneRailAShapeProfileDef::BaseWidth2() const {  double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcCraneRailAShapeProfileDef::setBaseWidth2(double v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
boost::optional< double > Ifc2x3::IfcCraneRailAShapeProfileDef::Radius() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcCraneRailAShapeProfileDef::setRadius(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
double Ifc2x3::IfcCraneRailAShapeProfileDef::HeadWidth() const {  double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcCraneRailAShapeProfileDef::setHeadWidth(double v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
double Ifc2x3::IfcCraneRailAShapeProfileDef::HeadDepth2() const {  double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcCraneRailAShapeProfileDef::setHeadDepth2(double v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
double Ifc2x3::IfcCraneRailAShapeProfileDef::HeadDepth3() const {  double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcCraneRailAShapeProfileDef::setHeadDepth3(double v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
double Ifc2x3::IfcCraneRailAShapeProfileDef::WebThickness() const {  double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcCraneRailAShapeProfileDef::setWebThickness(double v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }
double Ifc2x3::IfcCraneRailAShapeProfileDef::BaseWidth4() const {  double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcCraneRailAShapeProfileDef::setBaseWidth4(double v) { set_attribute_value(10, v);if constexpr (false)unset_attribute_value(10); }
double Ifc2x3::IfcCraneRailAShapeProfileDef::BaseDepth1() const {  double v = get_attribute_value(11); return v; }
void Ifc2x3::IfcCraneRailAShapeProfileDef::setBaseDepth1(double v) { set_attribute_value(11, v);if constexpr (false)unset_attribute_value(11); }
double Ifc2x3::IfcCraneRailAShapeProfileDef::BaseDepth2() const {  double v = get_attribute_value(12); return v; }
void Ifc2x3::IfcCraneRailAShapeProfileDef::setBaseDepth2(double v) { set_attribute_value(12, v);if constexpr (false)unset_attribute_value(12); }
double Ifc2x3::IfcCraneRailAShapeProfileDef::BaseDepth3() const {  double v = get_attribute_value(13); return v; }
void Ifc2x3::IfcCraneRailAShapeProfileDef::setBaseDepth3(double v) { set_attribute_value(13, v);if constexpr (false)unset_attribute_value(13); }
boost::optional< double > Ifc2x3::IfcCraneRailAShapeProfileDef::CentreOfGravityInY() const { if(get_attribute_value(14).isNull()) { return boost::none; } double v = get_attribute_value(14); return v; }
void Ifc2x3::IfcCraneRailAShapeProfileDef::setCentreOfGravityInY(boost::optional< double > v) { if (v) {set_attribute_value(14, *v);} else {unset_attribute_value(14);} }


const IfcParse::entity& Ifc2x3::IfcCraneRailAShapeProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[180]); }
const IfcParse::entity& Ifc2x3::IfcCraneRailAShapeProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[180]); }
Ifc2x3::IfcCraneRailAShapeProfileDef::IfcCraneRailAShapeProfileDef(IfcEntityInstanceData&& e) : IfcParameterizedProfileDef(std::move(e)) { }
Ifc2x3::IfcCraneRailAShapeProfileDef::IfcCraneRailAShapeProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcAxis2Placement2D* v3_Position, double v4_OverallHeight, double v5_BaseWidth2, boost::optional< double > v6_Radius, double v7_HeadWidth, double v8_HeadDepth2, double v9_HeadDepth3, double v10_WebThickness, double v11_BaseWidth4, double v12_BaseDepth1, double v13_BaseDepth2, double v14_BaseDepth3, boost::optional< double > v15_CentreOfGravityInY) : IfcParameterizedProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(15))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_OverallHeight));set_attribute_value(4, (v5_BaseWidth2)); if (v6_Radius) {set_attribute_value(5, (*v6_Radius)); }set_attribute_value(6, (v7_HeadWidth));set_attribute_value(7, (v8_HeadDepth2));set_attribute_value(8, (v9_HeadDepth3));set_attribute_value(9, (v10_WebThickness));set_attribute_value(10, (v11_BaseWidth4));set_attribute_value(11, (v12_BaseDepth1));set_attribute_value(12, (v13_BaseDepth2));set_attribute_value(13, (v14_BaseDepth3)); if (v15_CentreOfGravityInY) {set_attribute_value(14, (*v15_CentreOfGravityInY)); }; populate_derived(); }

// Function implementations for IfcCraneRailFShapeProfileDef
double Ifc2x3::IfcCraneRailFShapeProfileDef::OverallHeight() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcCraneRailFShapeProfileDef::setOverallHeight(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
double Ifc2x3::IfcCraneRailFShapeProfileDef::HeadWidth() const {  double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcCraneRailFShapeProfileDef::setHeadWidth(double v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
boost::optional< double > Ifc2x3::IfcCraneRailFShapeProfileDef::Radius() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcCraneRailFShapeProfileDef::setRadius(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
double Ifc2x3::IfcCraneRailFShapeProfileDef::HeadDepth2() const {  double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcCraneRailFShapeProfileDef::setHeadDepth2(double v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
double Ifc2x3::IfcCraneRailFShapeProfileDef::HeadDepth3() const {  double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcCraneRailFShapeProfileDef::setHeadDepth3(double v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
double Ifc2x3::IfcCraneRailFShapeProfileDef::WebThickness() const {  double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcCraneRailFShapeProfileDef::setWebThickness(double v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
double Ifc2x3::IfcCraneRailFShapeProfileDef::BaseDepth1() const {  double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcCraneRailFShapeProfileDef::setBaseDepth1(double v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }
double Ifc2x3::IfcCraneRailFShapeProfileDef::BaseDepth2() const {  double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcCraneRailFShapeProfileDef::setBaseDepth2(double v) { set_attribute_value(10, v);if constexpr (false)unset_attribute_value(10); }
boost::optional< double > Ifc2x3::IfcCraneRailFShapeProfileDef::CentreOfGravityInY() const { if(get_attribute_value(11).isNull()) { return boost::none; } double v = get_attribute_value(11); return v; }
void Ifc2x3::IfcCraneRailFShapeProfileDef::setCentreOfGravityInY(boost::optional< double > v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }


const IfcParse::entity& Ifc2x3::IfcCraneRailFShapeProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[181]); }
const IfcParse::entity& Ifc2x3::IfcCraneRailFShapeProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[181]); }
Ifc2x3::IfcCraneRailFShapeProfileDef::IfcCraneRailFShapeProfileDef(IfcEntityInstanceData&& e) : IfcParameterizedProfileDef(std::move(e)) { }
Ifc2x3::IfcCraneRailFShapeProfileDef::IfcCraneRailFShapeProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcAxis2Placement2D* v3_Position, double v4_OverallHeight, double v5_HeadWidth, boost::optional< double > v6_Radius, double v7_HeadDepth2, double v8_HeadDepth3, double v9_WebThickness, double v10_BaseDepth1, double v11_BaseDepth2, boost::optional< double > v12_CentreOfGravityInY) : IfcParameterizedProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(12))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_OverallHeight));set_attribute_value(4, (v5_HeadWidth)); if (v6_Radius) {set_attribute_value(5, (*v6_Radius)); }set_attribute_value(6, (v7_HeadDepth2));set_attribute_value(7, (v8_HeadDepth3));set_attribute_value(8, (v9_WebThickness));set_attribute_value(9, (v10_BaseDepth1));set_attribute_value(10, (v11_BaseDepth2)); if (v12_CentreOfGravityInY) {set_attribute_value(11, (*v12_CentreOfGravityInY)); }; populate_derived(); }

// Function implementations for IfcCrewResource


const IfcParse::entity& Ifc2x3::IfcCrewResource::declaration() const { return *((IfcParse::entity*)IFC2X3_types[182]); }
const IfcParse::entity& Ifc2x3::IfcCrewResource::Class() { return *((IfcParse::entity*)IFC2X3_types[182]); }
Ifc2x3::IfcCrewResource::IfcCrewResource(IfcEntityInstanceData&& e) : IfcConstructionResource(std::move(e)) { }
Ifc2x3::IfcCrewResource::IfcCrewResource(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< ::Ifc2x3::IfcResourceConsumptionEnum::Value > v8_ResourceConsumption, ::Ifc2x3::IfcMeasureWithUnit* v9_BaseQuantity) : IfcConstructionResource(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); } if (v6_ResourceIdentifier) {set_attribute_value(5, (*v6_ResourceIdentifier)); } if (v7_ResourceGroup) {set_attribute_value(6, (*v7_ResourceGroup)); } if (v8_ResourceConsumption) {set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcResourceConsumptionEnum::Class(),(size_t)*v8_ResourceConsumption))); }set_attribute_value(8, v9_BaseQuantity ? v9_BaseQuantity->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcCsgPrimitive3D
::Ifc2x3::IfcAxis2Placement3D* Ifc2x3::IfcCsgPrimitive3D::Position() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcAxis2Placement3D>(true); }
void Ifc2x3::IfcCsgPrimitive3D::setPosition(::Ifc2x3::IfcAxis2Placement3D* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcCsgPrimitive3D::declaration() const { return *((IfcParse::entity*)IFC2X3_types[183]); }
const IfcParse::entity& Ifc2x3::IfcCsgPrimitive3D::Class() { return *((IfcParse::entity*)IFC2X3_types[183]); }
Ifc2x3::IfcCsgPrimitive3D::IfcCsgPrimitive3D(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcCsgPrimitive3D::IfcCsgPrimitive3D(::Ifc2x3::IfcAxis2Placement3D* v1_Position) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, v1_Position ? v1_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcCsgSolid
::Ifc2x3::IfcCsgSelect* Ifc2x3::IfcCsgSolid::TreeRootExpression() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcCsgSelect>(true); }
void Ifc2x3::IfcCsgSolid::setTreeRootExpression(::Ifc2x3::IfcCsgSelect* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcCsgSolid::declaration() const { return *((IfcParse::entity*)IFC2X3_types[185]); }
const IfcParse::entity& Ifc2x3::IfcCsgSolid::Class() { return *((IfcParse::entity*)IFC2X3_types[185]); }
Ifc2x3::IfcCsgSolid::IfcCsgSolid(IfcEntityInstanceData&& e) : IfcSolidModel(std::move(e)) { }
Ifc2x3::IfcCsgSolid::IfcCsgSolid(::Ifc2x3::IfcCsgSelect* v1_TreeRootExpression) : IfcSolidModel(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, v1_TreeRootExpression ? v1_TreeRootExpression->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcCurrencyRelationship
::Ifc2x3::IfcMonetaryUnit* Ifc2x3::IfcCurrencyRelationship::RelatingMonetaryUnit() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcMonetaryUnit>(true); }
void Ifc2x3::IfcCurrencyRelationship::setRelatingMonetaryUnit(::Ifc2x3::IfcMonetaryUnit* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcMonetaryUnit* Ifc2x3::IfcCurrencyRelationship::RelatedMonetaryUnit() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcMonetaryUnit>(true); }
void Ifc2x3::IfcCurrencyRelationship::setRelatedMonetaryUnit(::Ifc2x3::IfcMonetaryUnit* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
double Ifc2x3::IfcCurrencyRelationship::ExchangeRate() const {  double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcCurrencyRelationship::setExchangeRate(double v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcDateAndTime* Ifc2x3::IfcCurrencyRelationship::RateDateTime() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcDateAndTime>(true); }
void Ifc2x3::IfcCurrencyRelationship::setRateDateTime(::Ifc2x3::IfcDateAndTime* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }
::Ifc2x3::IfcLibraryInformation* Ifc2x3::IfcCurrencyRelationship::RateSource() const { if(get_attribute_value(4).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcLibraryInformation>(true); }
void Ifc2x3::IfcCurrencyRelationship::setRateSource(::Ifc2x3::IfcLibraryInformation* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcCurrencyRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[188]); }
const IfcParse::entity& Ifc2x3::IfcCurrencyRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[188]); }
Ifc2x3::IfcCurrencyRelationship::IfcCurrencyRelationship(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcCurrencyRelationship::IfcCurrencyRelationship(::Ifc2x3::IfcMonetaryUnit* v1_RelatingMonetaryUnit, ::Ifc2x3::IfcMonetaryUnit* v2_RelatedMonetaryUnit, double v3_ExchangeRate, ::Ifc2x3::IfcDateAndTime* v4_RateDateTime, ::Ifc2x3::IfcLibraryInformation* v5_RateSource) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, v1_RelatingMonetaryUnit ? v1_RelatingMonetaryUnit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_RelatedMonetaryUnit ? v2_RelatedMonetaryUnit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, (v3_ExchangeRate));set_attribute_value(3, v4_RateDateTime ? v4_RateDateTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(4, v5_RateSource ? v5_RateSource->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcCurtainWall


const IfcParse::entity& Ifc2x3::IfcCurtainWall::declaration() const { return *((IfcParse::entity*)IFC2X3_types[189]); }
const IfcParse::entity& Ifc2x3::IfcCurtainWall::Class() { return *((IfcParse::entity*)IFC2X3_types[189]); }
Ifc2x3::IfcCurtainWall::IfcCurtainWall(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcCurtainWall::IfcCurtainWall(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcCurtainWallType
::Ifc2x3::IfcCurtainWallTypeEnum::Value Ifc2x3::IfcCurtainWallType::PredefinedType() const {  return ::Ifc2x3::IfcCurtainWallTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcCurtainWallType::setPredefinedType(::Ifc2x3::IfcCurtainWallTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcCurtainWallTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcCurtainWallType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[190]); }
const IfcParse::entity& Ifc2x3::IfcCurtainWallType::Class() { return *((IfcParse::entity*)IFC2X3_types[190]); }
Ifc2x3::IfcCurtainWallType::IfcCurtainWallType(IfcEntityInstanceData&& e) : IfcBuildingElementType(std::move(e)) { }
Ifc2x3::IfcCurtainWallType::IfcCurtainWallType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcCurtainWallTypeEnum::Value v10_PredefinedType) : IfcBuildingElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcCurtainWallTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcCurve


const IfcParse::entity& Ifc2x3::IfcCurve::declaration() const { return *((IfcParse::entity*)IFC2X3_types[193]); }
const IfcParse::entity& Ifc2x3::IfcCurve::Class() { return *((IfcParse::entity*)IFC2X3_types[193]); }
Ifc2x3::IfcCurve::IfcCurve(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcCurve::IfcCurve() : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(0))) { ; populate_derived(); }

// Function implementations for IfcCurveBoundedPlane
::Ifc2x3::IfcPlane* Ifc2x3::IfcCurveBoundedPlane::BasisSurface() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcPlane>(true); }
void Ifc2x3::IfcCurveBoundedPlane::setBasisSurface(::Ifc2x3::IfcPlane* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcCurve* Ifc2x3::IfcCurveBoundedPlane::OuterBoundary() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcCurve>(true); }
void Ifc2x3::IfcCurveBoundedPlane::setOuterBoundary(::Ifc2x3::IfcCurve* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
aggregate_of< ::Ifc2x3::IfcCurve >::ptr Ifc2x3::IfcCurveBoundedPlane::InnerBoundaries() const {  aggregate_of_instance::ptr es = get_attribute_value(2); return es->as< ::Ifc2x3::IfcCurve >(); }
void Ifc2x3::IfcCurveBoundedPlane::setInnerBoundaries(aggregate_of< ::Ifc2x3::IfcCurve >::ptr v) { set_attribute_value(2, (v)->generalize());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcCurveBoundedPlane::declaration() const { return *((IfcParse::entity*)IFC2X3_types[194]); }
const IfcParse::entity& Ifc2x3::IfcCurveBoundedPlane::Class() { return *((IfcParse::entity*)IFC2X3_types[194]); }
Ifc2x3::IfcCurveBoundedPlane::IfcCurveBoundedPlane(IfcEntityInstanceData&& e) : IfcBoundedSurface(std::move(e)) { }
Ifc2x3::IfcCurveBoundedPlane::IfcCurveBoundedPlane(::Ifc2x3::IfcPlane* v1_BasisSurface, ::Ifc2x3::IfcCurve* v2_OuterBoundary, aggregate_of< ::Ifc2x3::IfcCurve >::ptr v3_InnerBoundaries) : IfcBoundedSurface(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_BasisSurface ? v1_BasisSurface->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_OuterBoundary ? v2_OuterBoundary->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, (v3_InnerBoundaries)->generalize());; populate_derived(); }

// Function implementations for IfcCurveStyle
::Ifc2x3::IfcCurveFontOrScaledCurveFontSelect* Ifc2x3::IfcCurveStyle::CurveFont() const { if(get_attribute_value(1).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcCurveFontOrScaledCurveFontSelect>(true); }
void Ifc2x3::IfcCurveStyle::setCurveFont(::Ifc2x3::IfcCurveFontOrScaledCurveFontSelect* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcSizeSelect* Ifc2x3::IfcCurveStyle::CurveWidth() const { if(get_attribute_value(2).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcSizeSelect>(true); }
void Ifc2x3::IfcCurveStyle::setCurveWidth(::Ifc2x3::IfcSizeSelect* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcColour* Ifc2x3::IfcCurveStyle::CurveColour() const { if(get_attribute_value(3).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcColour>(true); }
void Ifc2x3::IfcCurveStyle::setCurveColour(::Ifc2x3::IfcColour* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcCurveStyle::declaration() const { return *((IfcParse::entity*)IFC2X3_types[197]); }
const IfcParse::entity& Ifc2x3::IfcCurveStyle::Class() { return *((IfcParse::entity*)IFC2X3_types[197]); }
Ifc2x3::IfcCurveStyle::IfcCurveStyle(IfcEntityInstanceData&& e) : IfcPresentationStyle(std::move(e)) { }
Ifc2x3::IfcCurveStyle::IfcCurveStyle(boost::optional< std::string > v1_Name, ::Ifc2x3::IfcCurveFontOrScaledCurveFontSelect* v2_CurveFont, ::Ifc2x3::IfcSizeSelect* v3_CurveWidth, ::Ifc2x3::IfcColour* v4_CurveColour) : IfcPresentationStyle(IfcEntityInstanceData(in_memory_attribute_storage(4))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, v2_CurveFont ? v2_CurveFont->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_CurveWidth ? v3_CurveWidth->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_CurveColour ? v4_CurveColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcCurveStyleFont
boost::optional< std::string > Ifc2x3::IfcCurveStyleFont::Name() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcCurveStyleFont::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
aggregate_of< ::Ifc2x3::IfcCurveStyleFontPattern >::ptr Ifc2x3::IfcCurveStyleFont::PatternList() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcCurveStyleFontPattern >(); }
void Ifc2x3::IfcCurveStyleFont::setPatternList(aggregate_of< ::Ifc2x3::IfcCurveStyleFontPattern >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcCurveStyleFont::declaration() const { return *((IfcParse::entity*)IFC2X3_types[198]); }
const IfcParse::entity& Ifc2x3::IfcCurveStyleFont::Class() { return *((IfcParse::entity*)IFC2X3_types[198]); }
Ifc2x3::IfcCurveStyleFont::IfcCurveStyleFont(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcCurveStyleFont::IfcCurveStyleFont(boost::optional< std::string > v1_Name, aggregate_of< ::Ifc2x3::IfcCurveStyleFontPattern >::ptr v2_PatternList) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (v2_PatternList)->generalize());; populate_derived(); }

// Function implementations for IfcCurveStyleFontAndScaling
boost::optional< std::string > Ifc2x3::IfcCurveStyleFontAndScaling::Name() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcCurveStyleFontAndScaling::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
::Ifc2x3::IfcCurveStyleFontSelect* Ifc2x3::IfcCurveStyleFontAndScaling::CurveFont() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcCurveStyleFontSelect>(true); }
void Ifc2x3::IfcCurveStyleFontAndScaling::setCurveFont(::Ifc2x3::IfcCurveStyleFontSelect* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
double Ifc2x3::IfcCurveStyleFontAndScaling::CurveFontScaling() const {  double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcCurveStyleFontAndScaling::setCurveFontScaling(double v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcCurveStyleFontAndScaling::declaration() const { return *((IfcParse::entity*)IFC2X3_types[199]); }
const IfcParse::entity& Ifc2x3::IfcCurveStyleFontAndScaling::Class() { return *((IfcParse::entity*)IFC2X3_types[199]); }
Ifc2x3::IfcCurveStyleFontAndScaling::IfcCurveStyleFontAndScaling(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcCurveStyleFontAndScaling::IfcCurveStyleFontAndScaling(boost::optional< std::string > v1_Name, ::Ifc2x3::IfcCurveStyleFontSelect* v2_CurveFont, double v3_CurveFontScaling) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, v2_CurveFont ? v2_CurveFont->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, (v3_CurveFontScaling));; populate_derived(); }

// Function implementations for IfcCurveStyleFontPattern
double Ifc2x3::IfcCurveStyleFontPattern::VisibleSegmentLength() const {  double v = get_attribute_value(0); return v; }
void Ifc2x3::IfcCurveStyleFontPattern::setVisibleSegmentLength(double v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
double Ifc2x3::IfcCurveStyleFontPattern::InvisibleSegmentLength() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcCurveStyleFontPattern::setInvisibleSegmentLength(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcCurveStyleFontPattern::declaration() const { return *((IfcParse::entity*)IFC2X3_types[200]); }
const IfcParse::entity& Ifc2x3::IfcCurveStyleFontPattern::Class() { return *((IfcParse::entity*)IFC2X3_types[200]); }
Ifc2x3::IfcCurveStyleFontPattern::IfcCurveStyleFontPattern(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcCurveStyleFontPattern::IfcCurveStyleFontPattern(double v1_VisibleSegmentLength, double v2_InvisibleSegmentLength) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (v1_VisibleSegmentLength));set_attribute_value(1, (v2_InvisibleSegmentLength));; populate_derived(); }

// Function implementations for IfcDamperType
::Ifc2x3::IfcDamperTypeEnum::Value Ifc2x3::IfcDamperType::PredefinedType() const {  return ::Ifc2x3::IfcDamperTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcDamperType::setPredefinedType(::Ifc2x3::IfcDamperTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcDamperTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcDamperType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[202]); }
const IfcParse::entity& Ifc2x3::IfcDamperType::Class() { return *((IfcParse::entity*)IFC2X3_types[202]); }
Ifc2x3::IfcDamperType::IfcDamperType(IfcEntityInstanceData&& e) : IfcFlowControllerType(std::move(e)) { }
Ifc2x3::IfcDamperType::IfcDamperType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcDamperTypeEnum::Value v10_PredefinedType) : IfcFlowControllerType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcDamperTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcDateAndTime
::Ifc2x3::IfcCalendarDate* Ifc2x3::IfcDateAndTime::DateComponent() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcCalendarDate>(true); }
void Ifc2x3::IfcDateAndTime::setDateComponent(::Ifc2x3::IfcCalendarDate* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcLocalTime* Ifc2x3::IfcDateAndTime::TimeComponent() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcLocalTime>(true); }
void Ifc2x3::IfcDateAndTime::setTimeComponent(::Ifc2x3::IfcLocalTime* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcDateAndTime::declaration() const { return *((IfcParse::entity*)IFC2X3_types[205]); }
const IfcParse::entity& Ifc2x3::IfcDateAndTime::Class() { return *((IfcParse::entity*)IFC2X3_types[205]); }
Ifc2x3::IfcDateAndTime::IfcDateAndTime(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcDateAndTime::IfcDateAndTime(::Ifc2x3::IfcCalendarDate* v1_DateComponent, ::Ifc2x3::IfcLocalTime* v2_TimeComponent) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_DateComponent ? v1_DateComponent->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_TimeComponent ? v2_TimeComponent->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcDefinedSymbol
::Ifc2x3::IfcDefinedSymbolSelect* Ifc2x3::IfcDefinedSymbol::Definition() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcDefinedSymbolSelect>(true); }
void Ifc2x3::IfcDefinedSymbol::setDefinition(::Ifc2x3::IfcDefinedSymbolSelect* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcCartesianTransformationOperator2D* Ifc2x3::IfcDefinedSymbol::Target() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcCartesianTransformationOperator2D>(true); }
void Ifc2x3::IfcDefinedSymbol::setTarget(::Ifc2x3::IfcCartesianTransformationOperator2D* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcDefinedSymbol::declaration() const { return *((IfcParse::entity*)IFC2X3_types[209]); }
const IfcParse::entity& Ifc2x3::IfcDefinedSymbol::Class() { return *((IfcParse::entity*)IFC2X3_types[209]); }
Ifc2x3::IfcDefinedSymbol::IfcDefinedSymbol(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcDefinedSymbol::IfcDefinedSymbol(::Ifc2x3::IfcDefinedSymbolSelect* v1_Definition, ::Ifc2x3::IfcCartesianTransformationOperator2D* v2_Target) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_Definition ? v1_Definition->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_Target ? v2_Target->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcDerivedProfileDef
::Ifc2x3::IfcProfileDef* Ifc2x3::IfcDerivedProfileDef::ParentProfile() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcProfileDef>(true); }
void Ifc2x3::IfcDerivedProfileDef::setParentProfile(::Ifc2x3::IfcProfileDef* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcCartesianTransformationOperator2D* Ifc2x3::IfcDerivedProfileDef::Operator() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcCartesianTransformationOperator2D>(true); }
void Ifc2x3::IfcDerivedProfileDef::setOperator(::Ifc2x3::IfcCartesianTransformationOperator2D* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }
boost::optional< std::string > Ifc2x3::IfcDerivedProfileDef::Label() const { if(get_attribute_value(4).isNull()) { return boost::none; } std::string v = get_attribute_value(4); return v; }
void Ifc2x3::IfcDerivedProfileDef::setLabel(boost::optional< std::string > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }


const IfcParse::entity& Ifc2x3::IfcDerivedProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[212]); }
const IfcParse::entity& Ifc2x3::IfcDerivedProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[212]); }
Ifc2x3::IfcDerivedProfileDef::IfcDerivedProfileDef(IfcEntityInstanceData&& e) : IfcProfileDef(std::move(e)) { }
Ifc2x3::IfcDerivedProfileDef::IfcDerivedProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcProfileDef* v3_ParentProfile, ::Ifc2x3::IfcCartesianTransformationOperator2D* v4_Operator, boost::optional< std::string > v5_Label) : IfcProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_ParentProfile ? v3_ParentProfile->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_Operator ? v4_Operator->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v5_Label) {set_attribute_value(4, (*v5_Label)); }; populate_derived(); }

// Function implementations for IfcDerivedUnit
aggregate_of< ::Ifc2x3::IfcDerivedUnitElement >::ptr Ifc2x3::IfcDerivedUnit::Elements() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcDerivedUnitElement >(); }
void Ifc2x3::IfcDerivedUnit::setElements(aggregate_of< ::Ifc2x3::IfcDerivedUnitElement >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcDerivedUnitEnum::Value Ifc2x3::IfcDerivedUnit::UnitType() const {  return ::Ifc2x3::IfcDerivedUnitEnum::FromString(get_attribute_value(1)); }
void Ifc2x3::IfcDerivedUnit::setUnitType(::Ifc2x3::IfcDerivedUnitEnum::Value v) { set_attribute_value(1, EnumerationReference(&::Ifc2x3::IfcDerivedUnitEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(1); }
boost::optional< std::string > Ifc2x3::IfcDerivedUnit::UserDefinedType() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcDerivedUnit::setUserDefinedType(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }


const IfcParse::entity& Ifc2x3::IfcDerivedUnit::declaration() const { return *((IfcParse::entity*)IFC2X3_types[213]); }
const IfcParse::entity& Ifc2x3::IfcDerivedUnit::Class() { return *((IfcParse::entity*)IFC2X3_types[213]); }
Ifc2x3::IfcDerivedUnit::IfcDerivedUnit(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcDerivedUnit::IfcDerivedUnit(aggregate_of< ::Ifc2x3::IfcDerivedUnitElement >::ptr v1_Elements, ::Ifc2x3::IfcDerivedUnitEnum::Value v2_UnitType, boost::optional< std::string > v3_UserDefinedType) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, (v1_Elements)->generalize());set_attribute_value(1, (EnumerationReference(&::Ifc2x3::IfcDerivedUnitEnum::Class(),(size_t)v2_UnitType))); if (v3_UserDefinedType) {set_attribute_value(2, (*v3_UserDefinedType)); }; populate_derived(); }

// Function implementations for IfcDerivedUnitElement
::Ifc2x3::IfcNamedUnit* Ifc2x3::IfcDerivedUnitElement::Unit() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcNamedUnit>(true); }
void Ifc2x3::IfcDerivedUnitElement::setUnit(::Ifc2x3::IfcNamedUnit* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
int Ifc2x3::IfcDerivedUnitElement::Exponent() const {  int v = get_attribute_value(1); return v; }
void Ifc2x3::IfcDerivedUnitElement::setExponent(int v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcDerivedUnitElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[214]); }
const IfcParse::entity& Ifc2x3::IfcDerivedUnitElement::Class() { return *((IfcParse::entity*)IFC2X3_types[214]); }
Ifc2x3::IfcDerivedUnitElement::IfcDerivedUnitElement(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcDerivedUnitElement::IfcDerivedUnitElement(::Ifc2x3::IfcNamedUnit* v1_Unit, int v2_Exponent) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_Unit ? v1_Unit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Exponent));; populate_derived(); }

// Function implementations for IfcDiameterDimension


const IfcParse::entity& Ifc2x3::IfcDiameterDimension::declaration() const { return *((IfcParse::entity*)IFC2X3_types[217]); }
const IfcParse::entity& Ifc2x3::IfcDiameterDimension::Class() { return *((IfcParse::entity*)IFC2X3_types[217]); }
Ifc2x3::IfcDiameterDimension::IfcDiameterDimension(IfcEntityInstanceData&& e) : IfcDimensionCurveDirectedCallout(std::move(e)) { }
Ifc2x3::IfcDiameterDimension::IfcDiameterDimension(aggregate_of< ::Ifc2x3::IfcDraughtingCalloutElement >::ptr v1_Contents) : IfcDimensionCurveDirectedCallout(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Contents)->generalize());; populate_derived(); }

// Function implementations for IfcDimensionCalloutRelationship


const IfcParse::entity& Ifc2x3::IfcDimensionCalloutRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[219]); }
const IfcParse::entity& Ifc2x3::IfcDimensionCalloutRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[219]); }
Ifc2x3::IfcDimensionCalloutRelationship::IfcDimensionCalloutRelationship(IfcEntityInstanceData&& e) : IfcDraughtingCalloutRelationship(std::move(e)) { }
Ifc2x3::IfcDimensionCalloutRelationship::IfcDimensionCalloutRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcDraughtingCallout* v3_RelatingDraughtingCallout, ::Ifc2x3::IfcDraughtingCallout* v4_RelatedDraughtingCallout) : IfcDraughtingCalloutRelationship(IfcEntityInstanceData(in_memory_attribute_storage(4))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_RelatingDraughtingCallout ? v3_RelatingDraughtingCallout->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_RelatedDraughtingCallout ? v4_RelatedDraughtingCallout->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcDimensionCurve

::Ifc2x3::IfcTerminatorSymbol::list::ptr Ifc2x3::IfcDimensionCurve::AnnotatedBySymbols() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[878], 3)->as<IfcTerminatorSymbol>(); }

const IfcParse::entity& Ifc2x3::IfcDimensionCurve::declaration() const { return *((IfcParse::entity*)IFC2X3_types[221]); }
const IfcParse::entity& Ifc2x3::IfcDimensionCurve::Class() { return *((IfcParse::entity*)IFC2X3_types[221]); }
Ifc2x3::IfcDimensionCurve::IfcDimensionCurve(IfcEntityInstanceData&& e) : IfcAnnotationCurveOccurrence(std::move(e)) { }
Ifc2x3::IfcDimensionCurve::IfcDimensionCurve(::Ifc2x3::IfcRepresentationItem* v1_Item, aggregate_of< ::Ifc2x3::IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationCurveOccurrence(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_Item ? v1_Item->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Styles)->generalize()); if (v3_Name) {set_attribute_value(2, (*v3_Name)); }; populate_derived(); }

// Function implementations for IfcDimensionCurveDirectedCallout


const IfcParse::entity& Ifc2x3::IfcDimensionCurveDirectedCallout::declaration() const { return *((IfcParse::entity*)IFC2X3_types[222]); }
const IfcParse::entity& Ifc2x3::IfcDimensionCurveDirectedCallout::Class() { return *((IfcParse::entity*)IFC2X3_types[222]); }
Ifc2x3::IfcDimensionCurveDirectedCallout::IfcDimensionCurveDirectedCallout(IfcEntityInstanceData&& e) : IfcDraughtingCallout(std::move(e)) { }
Ifc2x3::IfcDimensionCurveDirectedCallout::IfcDimensionCurveDirectedCallout(aggregate_of< ::Ifc2x3::IfcDraughtingCalloutElement >::ptr v1_Contents) : IfcDraughtingCallout(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Contents)->generalize());; populate_derived(); }

// Function implementations for IfcDimensionCurveTerminator
::Ifc2x3::IfcDimensionExtentUsage::Value Ifc2x3::IfcDimensionCurveTerminator::Role() const {  return ::Ifc2x3::IfcDimensionExtentUsage::FromString(get_attribute_value(4)); }
void Ifc2x3::IfcDimensionCurveTerminator::setRole(::Ifc2x3::IfcDimensionExtentUsage::Value v) { set_attribute_value(4, EnumerationReference(&::Ifc2x3::IfcDimensionExtentUsage::Class(), (size_t) v));if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcDimensionCurveTerminator::declaration() const { return *((IfcParse::entity*)IFC2X3_types[223]); }
const IfcParse::entity& Ifc2x3::IfcDimensionCurveTerminator::Class() { return *((IfcParse::entity*)IFC2X3_types[223]); }
Ifc2x3::IfcDimensionCurveTerminator::IfcDimensionCurveTerminator(IfcEntityInstanceData&& e) : IfcTerminatorSymbol(std::move(e)) { }
Ifc2x3::IfcDimensionCurveTerminator::IfcDimensionCurveTerminator(::Ifc2x3::IfcRepresentationItem* v1_Item, aggregate_of< ::Ifc2x3::IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name, ::Ifc2x3::IfcAnnotationCurveOccurrence* v4_AnnotatedCurve, ::Ifc2x3::IfcDimensionExtentUsage::Value v5_Role) : IfcTerminatorSymbol(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, v1_Item ? v1_Item->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Styles)->generalize()); if (v3_Name) {set_attribute_value(2, (*v3_Name)); }set_attribute_value(3, v4_AnnotatedCurve ? v4_AnnotatedCurve->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(4, (EnumerationReference(&::Ifc2x3::IfcDimensionExtentUsage::Class(),(size_t)v5_Role)));; populate_derived(); }

// Function implementations for IfcDimensionPair


const IfcParse::entity& Ifc2x3::IfcDimensionPair::declaration() const { return *((IfcParse::entity*)IFC2X3_types[225]); }
const IfcParse::entity& Ifc2x3::IfcDimensionPair::Class() { return *((IfcParse::entity*)IFC2X3_types[225]); }
Ifc2x3::IfcDimensionPair::IfcDimensionPair(IfcEntityInstanceData&& e) : IfcDraughtingCalloutRelationship(std::move(e)) { }
Ifc2x3::IfcDimensionPair::IfcDimensionPair(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcDraughtingCallout* v3_RelatingDraughtingCallout, ::Ifc2x3::IfcDraughtingCallout* v4_RelatedDraughtingCallout) : IfcDraughtingCalloutRelationship(IfcEntityInstanceData(in_memory_attribute_storage(4))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_RelatingDraughtingCallout ? v3_RelatingDraughtingCallout->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_RelatedDraughtingCallout ? v4_RelatedDraughtingCallout->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcDimensionalExponents
int Ifc2x3::IfcDimensionalExponents::LengthExponent() const {  int v = get_attribute_value(0); return v; }
void Ifc2x3::IfcDimensionalExponents::setLengthExponent(int v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
int Ifc2x3::IfcDimensionalExponents::MassExponent() const {  int v = get_attribute_value(1); return v; }
void Ifc2x3::IfcDimensionalExponents::setMassExponent(int v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
int Ifc2x3::IfcDimensionalExponents::TimeExponent() const {  int v = get_attribute_value(2); return v; }
void Ifc2x3::IfcDimensionalExponents::setTimeExponent(int v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
int Ifc2x3::IfcDimensionalExponents::ElectricCurrentExponent() const {  int v = get_attribute_value(3); return v; }
void Ifc2x3::IfcDimensionalExponents::setElectricCurrentExponent(int v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
int Ifc2x3::IfcDimensionalExponents::ThermodynamicTemperatureExponent() const {  int v = get_attribute_value(4); return v; }
void Ifc2x3::IfcDimensionalExponents::setThermodynamicTemperatureExponent(int v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
int Ifc2x3::IfcDimensionalExponents::AmountOfSubstanceExponent() const {  int v = get_attribute_value(5); return v; }
void Ifc2x3::IfcDimensionalExponents::setAmountOfSubstanceExponent(int v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
int Ifc2x3::IfcDimensionalExponents::LuminousIntensityExponent() const {  int v = get_attribute_value(6); return v; }
void Ifc2x3::IfcDimensionalExponents::setLuminousIntensityExponent(int v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcDimensionalExponents::declaration() const { return *((IfcParse::entity*)IFC2X3_types[218]); }
const IfcParse::entity& Ifc2x3::IfcDimensionalExponents::Class() { return *((IfcParse::entity*)IFC2X3_types[218]); }
Ifc2x3::IfcDimensionalExponents::IfcDimensionalExponents(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcDimensionalExponents::IfcDimensionalExponents(int v1_LengthExponent, int v2_MassExponent, int v3_TimeExponent, int v4_ElectricCurrentExponent, int v5_ThermodynamicTemperatureExponent, int v6_AmountOfSubstanceExponent, int v7_LuminousIntensityExponent) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_LengthExponent));set_attribute_value(1, (v2_MassExponent));set_attribute_value(2, (v3_TimeExponent));set_attribute_value(3, (v4_ElectricCurrentExponent));set_attribute_value(4, (v5_ThermodynamicTemperatureExponent));set_attribute_value(5, (v6_AmountOfSubstanceExponent));set_attribute_value(6, (v7_LuminousIntensityExponent));; populate_derived(); }

// Function implementations for IfcDirection
std::vector< double > /*[2:3]*/ Ifc2x3::IfcDirection::DirectionRatios() const {  std::vector< double > /*[2:3]*/ v = get_attribute_value(0); return v; }
void Ifc2x3::IfcDirection::setDirectionRatios(std::vector< double > /*[2:3]*/ v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcDirection::declaration() const { return *((IfcParse::entity*)IFC2X3_types[226]); }
const IfcParse::entity& Ifc2x3::IfcDirection::Class() { return *((IfcParse::entity*)IFC2X3_types[226]); }
Ifc2x3::IfcDirection::IfcDirection(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcDirection::IfcDirection(std::vector< double > /*[2:3]*/ v1_DirectionRatios) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_DirectionRatios));; populate_derived(); }

// Function implementations for IfcDiscreteAccessory


const IfcParse::entity& Ifc2x3::IfcDiscreteAccessory::declaration() const { return *((IfcParse::entity*)IFC2X3_types[228]); }
const IfcParse::entity& Ifc2x3::IfcDiscreteAccessory::Class() { return *((IfcParse::entity*)IFC2X3_types[228]); }
Ifc2x3::IfcDiscreteAccessory::IfcDiscreteAccessory(IfcEntityInstanceData&& e) : IfcElementComponent(std::move(e)) { }
Ifc2x3::IfcDiscreteAccessory::IfcDiscreteAccessory(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElementComponent(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcDiscreteAccessoryType


const IfcParse::entity& Ifc2x3::IfcDiscreteAccessoryType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[229]); }
const IfcParse::entity& Ifc2x3::IfcDiscreteAccessoryType::Class() { return *((IfcParse::entity*)IFC2X3_types[229]); }
Ifc2x3::IfcDiscreteAccessoryType::IfcDiscreteAccessoryType(IfcEntityInstanceData&& e) : IfcElementComponentType(std::move(e)) { }
Ifc2x3::IfcDiscreteAccessoryType::IfcDiscreteAccessoryType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementComponentType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcDistributionChamberElement


const IfcParse::entity& Ifc2x3::IfcDistributionChamberElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[230]); }
const IfcParse::entity& Ifc2x3::IfcDistributionChamberElement::Class() { return *((IfcParse::entity*)IFC2X3_types[230]); }
Ifc2x3::IfcDistributionChamberElement::IfcDistributionChamberElement(IfcEntityInstanceData&& e) : IfcDistributionFlowElement(std::move(e)) { }
Ifc2x3::IfcDistributionChamberElement::IfcDistributionChamberElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcDistributionChamberElementType
::Ifc2x3::IfcDistributionChamberElementTypeEnum::Value Ifc2x3::IfcDistributionChamberElementType::PredefinedType() const {  return ::Ifc2x3::IfcDistributionChamberElementTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcDistributionChamberElementType::setPredefinedType(::Ifc2x3::IfcDistributionChamberElementTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcDistributionChamberElementTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcDistributionChamberElementType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[231]); }
const IfcParse::entity& Ifc2x3::IfcDistributionChamberElementType::Class() { return *((IfcParse::entity*)IFC2X3_types[231]); }
Ifc2x3::IfcDistributionChamberElementType::IfcDistributionChamberElementType(IfcEntityInstanceData&& e) : IfcDistributionFlowElementType(std::move(e)) { }
Ifc2x3::IfcDistributionChamberElementType::IfcDistributionChamberElementType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcDistributionChamberElementTypeEnum::Value v10_PredefinedType) : IfcDistributionFlowElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcDistributionChamberElementTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcDistributionControlElement
boost::optional< std::string > Ifc2x3::IfcDistributionControlElement::ControlElementId() const { if(get_attribute_value(8).isNull()) { return boost::none; } std::string v = get_attribute_value(8); return v; }
void Ifc2x3::IfcDistributionControlElement::setControlElementId(boost::optional< std::string > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }

::Ifc2x3::IfcRelFlowControlElements::list::ptr Ifc2x3::IfcDistributionControlElement::AssignedToFlowElement() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[706], 4)->as<IfcRelFlowControlElements>(); }

const IfcParse::entity& Ifc2x3::IfcDistributionControlElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[233]); }
const IfcParse::entity& Ifc2x3::IfcDistributionControlElement::Class() { return *((IfcParse::entity*)IFC2X3_types[233]); }
Ifc2x3::IfcDistributionControlElement::IfcDistributionControlElement(IfcEntityInstanceData&& e) : IfcDistributionElement(std::move(e)) { }
Ifc2x3::IfcDistributionControlElement::IfcDistributionControlElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ControlElementId) : IfcDistributionElement(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ControlElementId) {set_attribute_value(8, (*v9_ControlElementId)); }; populate_derived(); }

// Function implementations for IfcDistributionControlElementType


const IfcParse::entity& Ifc2x3::IfcDistributionControlElementType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[234]); }
const IfcParse::entity& Ifc2x3::IfcDistributionControlElementType::Class() { return *((IfcParse::entity*)IFC2X3_types[234]); }
Ifc2x3::IfcDistributionControlElementType::IfcDistributionControlElementType(IfcEntityInstanceData&& e) : IfcDistributionElementType(std::move(e)) { }
Ifc2x3::IfcDistributionControlElementType::IfcDistributionControlElementType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionElementType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcDistributionElement


const IfcParse::entity& Ifc2x3::IfcDistributionElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[235]); }
const IfcParse::entity& Ifc2x3::IfcDistributionElement::Class() { return *((IfcParse::entity*)IFC2X3_types[235]); }
Ifc2x3::IfcDistributionElement::IfcDistributionElement(IfcEntityInstanceData&& e) : IfcElement(std::move(e)) { }
Ifc2x3::IfcDistributionElement::IfcDistributionElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcDistributionElementType


const IfcParse::entity& Ifc2x3::IfcDistributionElementType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[236]); }
const IfcParse::entity& Ifc2x3::IfcDistributionElementType::Class() { return *((IfcParse::entity*)IFC2X3_types[236]); }
Ifc2x3::IfcDistributionElementType::IfcDistributionElementType(IfcEntityInstanceData&& e) : IfcElementType(std::move(e)) { }
Ifc2x3::IfcDistributionElementType::IfcDistributionElementType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcDistributionFlowElement

::Ifc2x3::IfcRelFlowControlElements::list::ptr Ifc2x3::IfcDistributionFlowElement::HasControlElements() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[706], 5)->as<IfcRelFlowControlElements>(); }

const IfcParse::entity& Ifc2x3::IfcDistributionFlowElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[237]); }
const IfcParse::entity& Ifc2x3::IfcDistributionFlowElement::Class() { return *((IfcParse::entity*)IFC2X3_types[237]); }
Ifc2x3::IfcDistributionFlowElement::IfcDistributionFlowElement(IfcEntityInstanceData&& e) : IfcDistributionElement(std::move(e)) { }
Ifc2x3::IfcDistributionFlowElement::IfcDistributionFlowElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcDistributionFlowElementType


const IfcParse::entity& Ifc2x3::IfcDistributionFlowElementType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[238]); }
const IfcParse::entity& Ifc2x3::IfcDistributionFlowElementType::Class() { return *((IfcParse::entity*)IFC2X3_types[238]); }
Ifc2x3::IfcDistributionFlowElementType::IfcDistributionFlowElementType(IfcEntityInstanceData&& e) : IfcDistributionElementType(std::move(e)) { }
Ifc2x3::IfcDistributionFlowElementType::IfcDistributionFlowElementType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionElementType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcDistributionPort
boost::optional< ::Ifc2x3::IfcFlowDirectionEnum::Value > Ifc2x3::IfcDistributionPort::FlowDirection() const { if(get_attribute_value(7).isNull()) { return boost::none; } return ::Ifc2x3::IfcFlowDirectionEnum::FromString(get_attribute_value(7)); }
void Ifc2x3::IfcDistributionPort::setFlowDirection(boost::optional< ::Ifc2x3::IfcFlowDirectionEnum::Value > v) { if (v) {set_attribute_value(7, EnumerationReference(&::Ifc2x3::IfcFlowDirectionEnum::Class(), (size_t) *v));} else {unset_attribute_value(7);} }


const IfcParse::entity& Ifc2x3::IfcDistributionPort::declaration() const { return *((IfcParse::entity*)IFC2X3_types[239]); }
const IfcParse::entity& Ifc2x3::IfcDistributionPort::Class() { return *((IfcParse::entity*)IFC2X3_types[239]); }
Ifc2x3::IfcDistributionPort::IfcDistributionPort(IfcEntityInstanceData&& e) : IfcPort(std::move(e)) { }
Ifc2x3::IfcDistributionPort::IfcDistributionPort(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< ::Ifc2x3::IfcFlowDirectionEnum::Value > v8_FlowDirection) : IfcPort(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_FlowDirection) {set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcFlowDirectionEnum::Class(),(size_t)*v8_FlowDirection))); }; populate_derived(); }

// Function implementations for IfcDocumentElectronicFormat
boost::optional< std::string > Ifc2x3::IfcDocumentElectronicFormat::FileExtension() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcDocumentElectronicFormat::setFileExtension(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
boost::optional< std::string > Ifc2x3::IfcDocumentElectronicFormat::MimeContentType() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcDocumentElectronicFormat::setMimeContentType(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< std::string > Ifc2x3::IfcDocumentElectronicFormat::MimeSubtype() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcDocumentElectronicFormat::setMimeSubtype(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }


const IfcParse::entity& Ifc2x3::IfcDocumentElectronicFormat::declaration() const { return *((IfcParse::entity*)IFC2X3_types[241]); }
const IfcParse::entity& Ifc2x3::IfcDocumentElectronicFormat::Class() { return *((IfcParse::entity*)IFC2X3_types[241]); }
Ifc2x3::IfcDocumentElectronicFormat::IfcDocumentElectronicFormat(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcDocumentElectronicFormat::IfcDocumentElectronicFormat(boost::optional< std::string > v1_FileExtension, boost::optional< std::string > v2_MimeContentType, boost::optional< std::string > v3_MimeSubtype) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) {  if (v1_FileExtension) {set_attribute_value(0, (*v1_FileExtension)); } if (v2_MimeContentType) {set_attribute_value(1, (*v2_MimeContentType)); } if (v3_MimeSubtype) {set_attribute_value(2, (*v3_MimeSubtype)); }; populate_derived(); }

// Function implementations for IfcDocumentInformation
std::string Ifc2x3::IfcDocumentInformation::DocumentId() const {  std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcDocumentInformation::setDocumentId(std::string v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
std::string Ifc2x3::IfcDocumentInformation::Name() const {  std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcDocumentInformation::setName(std::string v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
boost::optional< std::string > Ifc2x3::IfcDocumentInformation::Description() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcDocumentInformation::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< aggregate_of< ::Ifc2x3::IfcDocumentReference >::ptr > Ifc2x3::IfcDocumentInformation::DocumentReferences() const { if(get_attribute_value(3).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(3); return es->as< ::Ifc2x3::IfcDocumentReference >(); }
void Ifc2x3::IfcDocumentInformation::setDocumentReferences(boost::optional< aggregate_of< ::Ifc2x3::IfcDocumentReference >::ptr > v) { if (v) {set_attribute_value(3, (*v)->generalize());} else {unset_attribute_value(3);} }
boost::optional< std::string > Ifc2x3::IfcDocumentInformation::Purpose() const { if(get_attribute_value(4).isNull()) { return boost::none; } std::string v = get_attribute_value(4); return v; }
void Ifc2x3::IfcDocumentInformation::setPurpose(boost::optional< std::string > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< std::string > Ifc2x3::IfcDocumentInformation::IntendedUse() const { if(get_attribute_value(5).isNull()) { return boost::none; } std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcDocumentInformation::setIntendedUse(boost::optional< std::string > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< std::string > Ifc2x3::IfcDocumentInformation::Scope() const { if(get_attribute_value(6).isNull()) { return boost::none; } std::string v = get_attribute_value(6); return v; }
void Ifc2x3::IfcDocumentInformation::setScope(boost::optional< std::string > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
boost::optional< std::string > Ifc2x3::IfcDocumentInformation::Revision() const { if(get_attribute_value(7).isNull()) { return boost::none; } std::string v = get_attribute_value(7); return v; }
void Ifc2x3::IfcDocumentInformation::setRevision(boost::optional< std::string > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
::Ifc2x3::IfcActorSelect* Ifc2x3::IfcDocumentInformation::DocumentOwner() const { if(get_attribute_value(8).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(8)))->as<::Ifc2x3::IfcActorSelect>(true); }
void Ifc2x3::IfcDocumentInformation::setDocumentOwner(::Ifc2x3::IfcActorSelect* v) { set_attribute_value(8, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(8); }
boost::optional< aggregate_of< ::Ifc2x3::IfcActorSelect >::ptr > Ifc2x3::IfcDocumentInformation::Editors() const { if(get_attribute_value(9).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(9); return es->as< ::Ifc2x3::IfcActorSelect >(); }
void Ifc2x3::IfcDocumentInformation::setEditors(boost::optional< aggregate_of< ::Ifc2x3::IfcActorSelect >::ptr > v) { if (v) {set_attribute_value(9, (*v)->generalize());} else {unset_attribute_value(9);} }
::Ifc2x3::IfcDateAndTime* Ifc2x3::IfcDocumentInformation::CreationTime() const { if(get_attribute_value(10).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(10)))->as<::Ifc2x3::IfcDateAndTime>(true); }
void Ifc2x3::IfcDocumentInformation::setCreationTime(::Ifc2x3::IfcDateAndTime* v) { set_attribute_value(10, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(10); }
::Ifc2x3::IfcDateAndTime* Ifc2x3::IfcDocumentInformation::LastRevisionTime() const { if(get_attribute_value(11).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(11)))->as<::Ifc2x3::IfcDateAndTime>(true); }
void Ifc2x3::IfcDocumentInformation::setLastRevisionTime(::Ifc2x3::IfcDateAndTime* v) { set_attribute_value(11, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(11); }
::Ifc2x3::IfcDocumentElectronicFormat* Ifc2x3::IfcDocumentInformation::ElectronicFormat() const { if(get_attribute_value(12).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(12)))->as<::Ifc2x3::IfcDocumentElectronicFormat>(true); }
void Ifc2x3::IfcDocumentInformation::setElectronicFormat(::Ifc2x3::IfcDocumentElectronicFormat* v) { set_attribute_value(12, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(12); }
::Ifc2x3::IfcCalendarDate* Ifc2x3::IfcDocumentInformation::ValidFrom() const { if(get_attribute_value(13).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(13)))->as<::Ifc2x3::IfcCalendarDate>(true); }
void Ifc2x3::IfcDocumentInformation::setValidFrom(::Ifc2x3::IfcCalendarDate* v) { set_attribute_value(13, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(13); }
::Ifc2x3::IfcCalendarDate* Ifc2x3::IfcDocumentInformation::ValidUntil() const { if(get_attribute_value(14).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(14)))->as<::Ifc2x3::IfcCalendarDate>(true); }
void Ifc2x3::IfcDocumentInformation::setValidUntil(::Ifc2x3::IfcCalendarDate* v) { set_attribute_value(14, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(14); }
boost::optional< ::Ifc2x3::IfcDocumentConfidentialityEnum::Value > Ifc2x3::IfcDocumentInformation::Confidentiality() const { if(get_attribute_value(15).isNull()) { return boost::none; } return ::Ifc2x3::IfcDocumentConfidentialityEnum::FromString(get_attribute_value(15)); }
void Ifc2x3::IfcDocumentInformation::setConfidentiality(boost::optional< ::Ifc2x3::IfcDocumentConfidentialityEnum::Value > v) { if (v) {set_attribute_value(15, EnumerationReference(&::Ifc2x3::IfcDocumentConfidentialityEnum::Class(), (size_t) *v));} else {unset_attribute_value(15);} }
boost::optional< ::Ifc2x3::IfcDocumentStatusEnum::Value > Ifc2x3::IfcDocumentInformation::Status() const { if(get_attribute_value(16).isNull()) { return boost::none; } return ::Ifc2x3::IfcDocumentStatusEnum::FromString(get_attribute_value(16)); }
void Ifc2x3::IfcDocumentInformation::setStatus(boost::optional< ::Ifc2x3::IfcDocumentStatusEnum::Value > v) { if (v) {set_attribute_value(16, EnumerationReference(&::Ifc2x3::IfcDocumentStatusEnum::Class(), (size_t) *v));} else {unset_attribute_value(16);} }

::Ifc2x3::IfcDocumentInformationRelationship::list::ptr Ifc2x3::IfcDocumentInformation::IsPointedTo() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[243], 1)->as<IfcDocumentInformationRelationship>(); }
::Ifc2x3::IfcDocumentInformationRelationship::list::ptr Ifc2x3::IfcDocumentInformation::IsPointer() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[243], 0)->as<IfcDocumentInformationRelationship>(); }

const IfcParse::entity& Ifc2x3::IfcDocumentInformation::declaration() const { return *((IfcParse::entity*)IFC2X3_types[242]); }
const IfcParse::entity& Ifc2x3::IfcDocumentInformation::Class() { return *((IfcParse::entity*)IFC2X3_types[242]); }
Ifc2x3::IfcDocumentInformation::IfcDocumentInformation(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcDocumentInformation::IfcDocumentInformation(std::string v1_DocumentId, std::string v2_Name, boost::optional< std::string > v3_Description, boost::optional< aggregate_of< ::Ifc2x3::IfcDocumentReference >::ptr > v4_DocumentReferences, boost::optional< std::string > v5_Purpose, boost::optional< std::string > v6_IntendedUse, boost::optional< std::string > v7_Scope, boost::optional< std::string > v8_Revision, ::Ifc2x3::IfcActorSelect* v9_DocumentOwner, boost::optional< aggregate_of< ::Ifc2x3::IfcActorSelect >::ptr > v10_Editors, ::Ifc2x3::IfcDateAndTime* v11_CreationTime, ::Ifc2x3::IfcDateAndTime* v12_LastRevisionTime, ::Ifc2x3::IfcDocumentElectronicFormat* v13_ElectronicFormat, ::Ifc2x3::IfcCalendarDate* v14_ValidFrom, ::Ifc2x3::IfcCalendarDate* v15_ValidUntil, boost::optional< ::Ifc2x3::IfcDocumentConfidentialityEnum::Value > v16_Confidentiality, boost::optional< ::Ifc2x3::IfcDocumentStatusEnum::Value > v17_Status) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(17))) { set_attribute_value(0, (v1_DocumentId));set_attribute_value(1, (v2_Name)); if (v3_Description) {set_attribute_value(2, (*v3_Description)); } if (v4_DocumentReferences) {set_attribute_value(3, (*v4_DocumentReferences)->generalize()); } if (v5_Purpose) {set_attribute_value(4, (*v5_Purpose)); } if (v6_IntendedUse) {set_attribute_value(5, (*v6_IntendedUse)); } if (v7_Scope) {set_attribute_value(6, (*v7_Scope)); } if (v8_Revision) {set_attribute_value(7, (*v8_Revision)); }set_attribute_value(8, v9_DocumentOwner ? v9_DocumentOwner->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v10_Editors) {set_attribute_value(9, (*v10_Editors)->generalize()); }set_attribute_value(10, v11_CreationTime ? v11_CreationTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(11, v12_LastRevisionTime ? v12_LastRevisionTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(12, v13_ElectronicFormat ? v13_ElectronicFormat->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(13, v14_ValidFrom ? v14_ValidFrom->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(14, v15_ValidUntil ? v15_ValidUntil->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v16_Confidentiality) {set_attribute_value(15, (EnumerationReference(&::Ifc2x3::IfcDocumentConfidentialityEnum::Class(),(size_t)*v16_Confidentiality))); } if (v17_Status) {set_attribute_value(16, (EnumerationReference(&::Ifc2x3::IfcDocumentStatusEnum::Class(),(size_t)*v17_Status))); }; populate_derived(); }

// Function implementations for IfcDocumentInformationRelationship
::Ifc2x3::IfcDocumentInformation* Ifc2x3::IfcDocumentInformationRelationship::RelatingDocument() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcDocumentInformation>(true); }
void Ifc2x3::IfcDocumentInformationRelationship::setRelatingDocument(::Ifc2x3::IfcDocumentInformation* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcDocumentInformation >::ptr Ifc2x3::IfcDocumentInformationRelationship::RelatedDocuments() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcDocumentInformation >(); }
void Ifc2x3::IfcDocumentInformationRelationship::setRelatedDocuments(aggregate_of< ::Ifc2x3::IfcDocumentInformation >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }
boost::optional< std::string > Ifc2x3::IfcDocumentInformationRelationship::RelationshipType() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcDocumentInformationRelationship::setRelationshipType(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }


const IfcParse::entity& Ifc2x3::IfcDocumentInformationRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[243]); }
const IfcParse::entity& Ifc2x3::IfcDocumentInformationRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[243]); }
Ifc2x3::IfcDocumentInformationRelationship::IfcDocumentInformationRelationship(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcDocumentInformationRelationship::IfcDocumentInformationRelationship(::Ifc2x3::IfcDocumentInformation* v1_RelatingDocument, aggregate_of< ::Ifc2x3::IfcDocumentInformation >::ptr v2_RelatedDocuments, boost::optional< std::string > v3_RelationshipType) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_RelatingDocument ? v1_RelatingDocument->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_RelatedDocuments)->generalize()); if (v3_RelationshipType) {set_attribute_value(2, (*v3_RelationshipType)); }; populate_derived(); }

// Function implementations for IfcDocumentReference

::Ifc2x3::IfcDocumentInformation::list::ptr Ifc2x3::IfcDocumentReference::ReferenceToDocument() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[242], 3)->as<IfcDocumentInformation>(); }

const IfcParse::entity& Ifc2x3::IfcDocumentReference::declaration() const { return *((IfcParse::entity*)IFC2X3_types[244]); }
const IfcParse::entity& Ifc2x3::IfcDocumentReference::Class() { return *((IfcParse::entity*)IFC2X3_types[244]); }
Ifc2x3::IfcDocumentReference::IfcDocumentReference(IfcEntityInstanceData&& e) : IfcExternalReference(std::move(e)) { }
Ifc2x3::IfcDocumentReference::IfcDocumentReference(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference(IfcEntityInstanceData(in_memory_attribute_storage(3))) {  if (v1_Location) {set_attribute_value(0, (*v1_Location)); } if (v2_ItemReference) {set_attribute_value(1, (*v2_ItemReference)); } if (v3_Name) {set_attribute_value(2, (*v3_Name)); }; populate_derived(); }

// Function implementations for IfcDoor
boost::optional< double > Ifc2x3::IfcDoor::OverallHeight() const { if(get_attribute_value(8).isNull()) { return boost::none; } double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcDoor::setOverallHeight(boost::optional< double > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
boost::optional< double > Ifc2x3::IfcDoor::OverallWidth() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcDoor::setOverallWidth(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }


const IfcParse::entity& Ifc2x3::IfcDoor::declaration() const { return *((IfcParse::entity*)IFC2X3_types[247]); }
const IfcParse::entity& Ifc2x3::IfcDoor::Class() { return *((IfcParse::entity*)IFC2X3_types[247]); }
Ifc2x3::IfcDoor::IfcDoor(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcDoor::IfcDoor(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_OverallHeight, boost::optional< double > v10_OverallWidth) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_OverallHeight) {set_attribute_value(8, (*v9_OverallHeight)); } if (v10_OverallWidth) {set_attribute_value(9, (*v10_OverallWidth)); }; populate_derived(); }

// Function implementations for IfcDoorLiningProperties
boost::optional< double > Ifc2x3::IfcDoorLiningProperties::LiningDepth() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcDoorLiningProperties::setLiningDepth(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< double > Ifc2x3::IfcDoorLiningProperties::LiningThickness() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcDoorLiningProperties::setLiningThickness(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< double > Ifc2x3::IfcDoorLiningProperties::ThresholdDepth() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcDoorLiningProperties::setThresholdDepth(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
boost::optional< double > Ifc2x3::IfcDoorLiningProperties::ThresholdThickness() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcDoorLiningProperties::setThresholdThickness(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
boost::optional< double > Ifc2x3::IfcDoorLiningProperties::TransomThickness() const { if(get_attribute_value(8).isNull()) { return boost::none; } double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcDoorLiningProperties::setTransomThickness(boost::optional< double > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
boost::optional< double > Ifc2x3::IfcDoorLiningProperties::TransomOffset() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcDoorLiningProperties::setTransomOffset(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
boost::optional< double > Ifc2x3::IfcDoorLiningProperties::LiningOffset() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcDoorLiningProperties::setLiningOffset(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
boost::optional< double > Ifc2x3::IfcDoorLiningProperties::ThresholdOffset() const { if(get_attribute_value(11).isNull()) { return boost::none; } double v = get_attribute_value(11); return v; }
void Ifc2x3::IfcDoorLiningProperties::setThresholdOffset(boost::optional< double > v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
boost::optional< double > Ifc2x3::IfcDoorLiningProperties::CasingThickness() const { if(get_attribute_value(12).isNull()) { return boost::none; } double v = get_attribute_value(12); return v; }
void Ifc2x3::IfcDoorLiningProperties::setCasingThickness(boost::optional< double > v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
boost::optional< double > Ifc2x3::IfcDoorLiningProperties::CasingDepth() const { if(get_attribute_value(13).isNull()) { return boost::none; } double v = get_attribute_value(13); return v; }
void Ifc2x3::IfcDoorLiningProperties::setCasingDepth(boost::optional< double > v) { if (v) {set_attribute_value(13, *v);} else {unset_attribute_value(13);} }
::Ifc2x3::IfcShapeAspect* Ifc2x3::IfcDoorLiningProperties::ShapeAspectStyle() const { if(get_attribute_value(14).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(14)))->as<::Ifc2x3::IfcShapeAspect>(true); }
void Ifc2x3::IfcDoorLiningProperties::setShapeAspectStyle(::Ifc2x3::IfcShapeAspect* v) { set_attribute_value(14, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(14); }


const IfcParse::entity& Ifc2x3::IfcDoorLiningProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[248]); }
const IfcParse::entity& Ifc2x3::IfcDoorLiningProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[248]); }
Ifc2x3::IfcDoorLiningProperties::IfcDoorLiningProperties(IfcEntityInstanceData&& e) : IfcPropertySetDefinition(std::move(e)) { }
Ifc2x3::IfcDoorLiningProperties::IfcDoorLiningProperties(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_LiningDepth, boost::optional< double > v6_LiningThickness, boost::optional< double > v7_ThresholdDepth, boost::optional< double > v8_ThresholdThickness, boost::optional< double > v9_TransomThickness, boost::optional< double > v10_TransomOffset, boost::optional< double > v11_LiningOffset, boost::optional< double > v12_ThresholdOffset, boost::optional< double > v13_CasingThickness, boost::optional< double > v14_CasingDepth, ::Ifc2x3::IfcShapeAspect* v15_ShapeAspectStyle) : IfcPropertySetDefinition(IfcEntityInstanceData(in_memory_attribute_storage(15))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_LiningDepth) {set_attribute_value(4, (*v5_LiningDepth)); } if (v6_LiningThickness) {set_attribute_value(5, (*v6_LiningThickness)); } if (v7_ThresholdDepth) {set_attribute_value(6, (*v7_ThresholdDepth)); } if (v8_ThresholdThickness) {set_attribute_value(7, (*v8_ThresholdThickness)); } if (v9_TransomThickness) {set_attribute_value(8, (*v9_TransomThickness)); } if (v10_TransomOffset) {set_attribute_value(9, (*v10_TransomOffset)); } if (v11_LiningOffset) {set_attribute_value(10, (*v11_LiningOffset)); } if (v12_ThresholdOffset) {set_attribute_value(11, (*v12_ThresholdOffset)); } if (v13_CasingThickness) {set_attribute_value(12, (*v13_CasingThickness)); } if (v14_CasingDepth) {set_attribute_value(13, (*v14_CasingDepth)); }set_attribute_value(14, v15_ShapeAspectStyle ? v15_ShapeAspectStyle->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcDoorPanelProperties
boost::optional< double > Ifc2x3::IfcDoorPanelProperties::PanelDepth() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcDoorPanelProperties::setPanelDepth(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
::Ifc2x3::IfcDoorPanelOperationEnum::Value Ifc2x3::IfcDoorPanelProperties::PanelOperation() const {  return ::Ifc2x3::IfcDoorPanelOperationEnum::FromString(get_attribute_value(5)); }
void Ifc2x3::IfcDoorPanelProperties::setPanelOperation(::Ifc2x3::IfcDoorPanelOperationEnum::Value v) { set_attribute_value(5, EnumerationReference(&::Ifc2x3::IfcDoorPanelOperationEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(5); }
boost::optional< double > Ifc2x3::IfcDoorPanelProperties::PanelWidth() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcDoorPanelProperties::setPanelWidth(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
::Ifc2x3::IfcDoorPanelPositionEnum::Value Ifc2x3::IfcDoorPanelProperties::PanelPosition() const {  return ::Ifc2x3::IfcDoorPanelPositionEnum::FromString(get_attribute_value(7)); }
void Ifc2x3::IfcDoorPanelProperties::setPanelPosition(::Ifc2x3::IfcDoorPanelPositionEnum::Value v) { set_attribute_value(7, EnumerationReference(&::Ifc2x3::IfcDoorPanelPositionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }
::Ifc2x3::IfcShapeAspect* Ifc2x3::IfcDoorPanelProperties::ShapeAspectStyle() const { if(get_attribute_value(8).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(8)))->as<::Ifc2x3::IfcShapeAspect>(true); }
void Ifc2x3::IfcDoorPanelProperties::setShapeAspectStyle(::Ifc2x3::IfcShapeAspect* v) { set_attribute_value(8, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(8); }


const IfcParse::entity& Ifc2x3::IfcDoorPanelProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[251]); }
const IfcParse::entity& Ifc2x3::IfcDoorPanelProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[251]); }
Ifc2x3::IfcDoorPanelProperties::IfcDoorPanelProperties(IfcEntityInstanceData&& e) : IfcPropertySetDefinition(std::move(e)) { }
Ifc2x3::IfcDoorPanelProperties::IfcDoorPanelProperties(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_PanelDepth, ::Ifc2x3::IfcDoorPanelOperationEnum::Value v6_PanelOperation, boost::optional< double > v7_PanelWidth, ::Ifc2x3::IfcDoorPanelPositionEnum::Value v8_PanelPosition, ::Ifc2x3::IfcShapeAspect* v9_ShapeAspectStyle) : IfcPropertySetDefinition(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_PanelDepth) {set_attribute_value(4, (*v5_PanelDepth)); }set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcDoorPanelOperationEnum::Class(),(size_t)v6_PanelOperation))); if (v7_PanelWidth) {set_attribute_value(6, (*v7_PanelWidth)); }set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcDoorPanelPositionEnum::Class(),(size_t)v8_PanelPosition)));set_attribute_value(8, v9_ShapeAspectStyle ? v9_ShapeAspectStyle->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcDoorStyle
::Ifc2x3::IfcDoorStyleOperationEnum::Value Ifc2x3::IfcDoorStyle::OperationType() const {  return ::Ifc2x3::IfcDoorStyleOperationEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcDoorStyle::setOperationType(::Ifc2x3::IfcDoorStyleOperationEnum::Value v) { set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcDoorStyleOperationEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }
::Ifc2x3::IfcDoorStyleConstructionEnum::Value Ifc2x3::IfcDoorStyle::ConstructionType() const {  return ::Ifc2x3::IfcDoorStyleConstructionEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcDoorStyle::setConstructionType(::Ifc2x3::IfcDoorStyleConstructionEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcDoorStyleConstructionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
bool Ifc2x3::IfcDoorStyle::ParameterTakesPrecedence() const {  bool v = get_attribute_value(10); return v; }
void Ifc2x3::IfcDoorStyle::setParameterTakesPrecedence(bool v) { set_attribute_value(10, v);if constexpr (false)unset_attribute_value(10); }
bool Ifc2x3::IfcDoorStyle::Sizeable() const {  bool v = get_attribute_value(11); return v; }
void Ifc2x3::IfcDoorStyle::setSizeable(bool v) { set_attribute_value(11, v);if constexpr (false)unset_attribute_value(11); }


const IfcParse::entity& Ifc2x3::IfcDoorStyle::declaration() const { return *((IfcParse::entity*)IFC2X3_types[252]); }
const IfcParse::entity& Ifc2x3::IfcDoorStyle::Class() { return *((IfcParse::entity*)IFC2X3_types[252]); }
Ifc2x3::IfcDoorStyle::IfcDoorStyle(IfcEntityInstanceData&& e) : IfcTypeProduct(std::move(e)) { }
Ifc2x3::IfcDoorStyle::IfcDoorStyle(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, ::Ifc2x3::IfcDoorStyleOperationEnum::Value v9_OperationType, ::Ifc2x3::IfcDoorStyleConstructionEnum::Value v10_ConstructionType, bool v11_ParameterTakesPrecedence, bool v12_Sizeable) : IfcTypeProduct(IfcEntityInstanceData(in_memory_attribute_storage(12))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcDoorStyleOperationEnum::Class(),(size_t)v9_OperationType)));set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcDoorStyleConstructionEnum::Class(),(size_t)v10_ConstructionType)));set_attribute_value(10, (v11_ParameterTakesPrecedence));set_attribute_value(11, (v12_Sizeable));; populate_derived(); }

// Function implementations for IfcDraughtingCallout
aggregate_of< ::Ifc2x3::IfcDraughtingCalloutElement >::ptr Ifc2x3::IfcDraughtingCallout::Contents() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcDraughtingCalloutElement >(); }
void Ifc2x3::IfcDraughtingCallout::setContents(aggregate_of< ::Ifc2x3::IfcDraughtingCalloutElement >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }

::Ifc2x3::IfcDraughtingCalloutRelationship::list::ptr Ifc2x3::IfcDraughtingCallout::IsRelatedFromCallout() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[258], 3)->as<IfcDraughtingCalloutRelationship>(); }
::Ifc2x3::IfcDraughtingCalloutRelationship::list::ptr Ifc2x3::IfcDraughtingCallout::IsRelatedToCallout() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[258], 2)->as<IfcDraughtingCalloutRelationship>(); }

const IfcParse::entity& Ifc2x3::IfcDraughtingCallout::declaration() const { return *((IfcParse::entity*)IFC2X3_types[256]); }
const IfcParse::entity& Ifc2x3::IfcDraughtingCallout::Class() { return *((IfcParse::entity*)IFC2X3_types[256]); }
Ifc2x3::IfcDraughtingCallout::IfcDraughtingCallout(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcDraughtingCallout::IfcDraughtingCallout(aggregate_of< ::Ifc2x3::IfcDraughtingCalloutElement >::ptr v1_Contents) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Contents)->generalize());; populate_derived(); }

// Function implementations for IfcDraughtingCalloutRelationship
boost::optional< std::string > Ifc2x3::IfcDraughtingCalloutRelationship::Name() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcDraughtingCalloutRelationship::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
boost::optional< std::string > Ifc2x3::IfcDraughtingCalloutRelationship::Description() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcDraughtingCalloutRelationship::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
::Ifc2x3::IfcDraughtingCallout* Ifc2x3::IfcDraughtingCalloutRelationship::RelatingDraughtingCallout() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcDraughtingCallout>(true); }
void Ifc2x3::IfcDraughtingCalloutRelationship::setRelatingDraughtingCallout(::Ifc2x3::IfcDraughtingCallout* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcDraughtingCallout* Ifc2x3::IfcDraughtingCalloutRelationship::RelatedDraughtingCallout() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcDraughtingCallout>(true); }
void Ifc2x3::IfcDraughtingCalloutRelationship::setRelatedDraughtingCallout(::Ifc2x3::IfcDraughtingCallout* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcDraughtingCalloutRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[258]); }
const IfcParse::entity& Ifc2x3::IfcDraughtingCalloutRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[258]); }
Ifc2x3::IfcDraughtingCalloutRelationship::IfcDraughtingCalloutRelationship(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcDraughtingCalloutRelationship::IfcDraughtingCalloutRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcDraughtingCallout* v3_RelatingDraughtingCallout, ::Ifc2x3::IfcDraughtingCallout* v4_RelatedDraughtingCallout) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(4))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_RelatingDraughtingCallout ? v3_RelatingDraughtingCallout->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_RelatedDraughtingCallout ? v4_RelatedDraughtingCallout->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcDraughtingPreDefinedColour


const IfcParse::entity& Ifc2x3::IfcDraughtingPreDefinedColour::declaration() const { return *((IfcParse::entity*)IFC2X3_types[259]); }
const IfcParse::entity& Ifc2x3::IfcDraughtingPreDefinedColour::Class() { return *((IfcParse::entity*)IFC2X3_types[259]); }
Ifc2x3::IfcDraughtingPreDefinedColour::IfcDraughtingPreDefinedColour(IfcEntityInstanceData&& e) : IfcPreDefinedColour(std::move(e)) { }
Ifc2x3::IfcDraughtingPreDefinedColour::IfcDraughtingPreDefinedColour(std::string v1_Name) : IfcPreDefinedColour(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Name));; populate_derived(); }

// Function implementations for IfcDraughtingPreDefinedCurveFont


const IfcParse::entity& Ifc2x3::IfcDraughtingPreDefinedCurveFont::declaration() const { return *((IfcParse::entity*)IFC2X3_types[260]); }
const IfcParse::entity& Ifc2x3::IfcDraughtingPreDefinedCurveFont::Class() { return *((IfcParse::entity*)IFC2X3_types[260]); }
Ifc2x3::IfcDraughtingPreDefinedCurveFont::IfcDraughtingPreDefinedCurveFont(IfcEntityInstanceData&& e) : IfcPreDefinedCurveFont(std::move(e)) { }
Ifc2x3::IfcDraughtingPreDefinedCurveFont::IfcDraughtingPreDefinedCurveFont(std::string v1_Name) : IfcPreDefinedCurveFont(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Name));; populate_derived(); }

// Function implementations for IfcDraughtingPreDefinedTextFont


const IfcParse::entity& Ifc2x3::IfcDraughtingPreDefinedTextFont::declaration() const { return *((IfcParse::entity*)IFC2X3_types[261]); }
const IfcParse::entity& Ifc2x3::IfcDraughtingPreDefinedTextFont::Class() { return *((IfcParse::entity*)IFC2X3_types[261]); }
Ifc2x3::IfcDraughtingPreDefinedTextFont::IfcDraughtingPreDefinedTextFont(IfcEntityInstanceData&& e) : IfcPreDefinedTextFont(std::move(e)) { }
Ifc2x3::IfcDraughtingPreDefinedTextFont::IfcDraughtingPreDefinedTextFont(std::string v1_Name) : IfcPreDefinedTextFont(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Name));; populate_derived(); }

// Function implementations for IfcDuctFittingType
::Ifc2x3::IfcDuctFittingTypeEnum::Value Ifc2x3::IfcDuctFittingType::PredefinedType() const {  return ::Ifc2x3::IfcDuctFittingTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcDuctFittingType::setPredefinedType(::Ifc2x3::IfcDuctFittingTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcDuctFittingTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcDuctFittingType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[262]); }
const IfcParse::entity& Ifc2x3::IfcDuctFittingType::Class() { return *((IfcParse::entity*)IFC2X3_types[262]); }
Ifc2x3::IfcDuctFittingType::IfcDuctFittingType(IfcEntityInstanceData&& e) : IfcFlowFittingType(std::move(e)) { }
Ifc2x3::IfcDuctFittingType::IfcDuctFittingType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcDuctFittingTypeEnum::Value v10_PredefinedType) : IfcFlowFittingType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcDuctFittingTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcDuctSegmentType
::Ifc2x3::IfcDuctSegmentTypeEnum::Value Ifc2x3::IfcDuctSegmentType::PredefinedType() const {  return ::Ifc2x3::IfcDuctSegmentTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcDuctSegmentType::setPredefinedType(::Ifc2x3::IfcDuctSegmentTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcDuctSegmentTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcDuctSegmentType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[264]); }
const IfcParse::entity& Ifc2x3::IfcDuctSegmentType::Class() { return *((IfcParse::entity*)IFC2X3_types[264]); }
Ifc2x3::IfcDuctSegmentType::IfcDuctSegmentType(IfcEntityInstanceData&& e) : IfcFlowSegmentType(std::move(e)) { }
Ifc2x3::IfcDuctSegmentType::IfcDuctSegmentType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcDuctSegmentTypeEnum::Value v10_PredefinedType) : IfcFlowSegmentType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcDuctSegmentTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcDuctSilencerType
::Ifc2x3::IfcDuctSilencerTypeEnum::Value Ifc2x3::IfcDuctSilencerType::PredefinedType() const {  return ::Ifc2x3::IfcDuctSilencerTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcDuctSilencerType::setPredefinedType(::Ifc2x3::IfcDuctSilencerTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcDuctSilencerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcDuctSilencerType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[266]); }
const IfcParse::entity& Ifc2x3::IfcDuctSilencerType::Class() { return *((IfcParse::entity*)IFC2X3_types[266]); }
Ifc2x3::IfcDuctSilencerType::IfcDuctSilencerType(IfcEntityInstanceData&& e) : IfcFlowTreatmentDeviceType(std::move(e)) { }
Ifc2x3::IfcDuctSilencerType::IfcDuctSilencerType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcDuctSilencerTypeEnum::Value v10_PredefinedType) : IfcFlowTreatmentDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcDuctSilencerTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcEdge
::Ifc2x3::IfcVertex* Ifc2x3::IfcEdge::EdgeStart() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcVertex>(true); }
void Ifc2x3::IfcEdge::setEdgeStart(::Ifc2x3::IfcVertex* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcVertex* Ifc2x3::IfcEdge::EdgeEnd() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcVertex>(true); }
void Ifc2x3::IfcEdge::setEdgeEnd(::Ifc2x3::IfcVertex* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcEdge::declaration() const { return *((IfcParse::entity*)IFC2X3_types[269]); }
const IfcParse::entity& Ifc2x3::IfcEdge::Class() { return *((IfcParse::entity*)IFC2X3_types[269]); }
Ifc2x3::IfcEdge::IfcEdge(IfcEntityInstanceData&& e) : IfcTopologicalRepresentationItem(std::move(e)) { }
Ifc2x3::IfcEdge::IfcEdge(::Ifc2x3::IfcVertex* v1_EdgeStart, ::Ifc2x3::IfcVertex* v2_EdgeEnd) : IfcTopologicalRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_EdgeStart ? v1_EdgeStart->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_EdgeEnd ? v2_EdgeEnd->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcEdgeCurve
::Ifc2x3::IfcCurve* Ifc2x3::IfcEdgeCurve::EdgeGeometry() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcCurve>(true); }
void Ifc2x3::IfcEdgeCurve::setEdgeGeometry(::Ifc2x3::IfcCurve* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
bool Ifc2x3::IfcEdgeCurve::SameSense() const {  bool v = get_attribute_value(3); return v; }
void Ifc2x3::IfcEdgeCurve::setSameSense(bool v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcEdgeCurve::declaration() const { return *((IfcParse::entity*)IFC2X3_types[270]); }
const IfcParse::entity& Ifc2x3::IfcEdgeCurve::Class() { return *((IfcParse::entity*)IFC2X3_types[270]); }
Ifc2x3::IfcEdgeCurve::IfcEdgeCurve(IfcEntityInstanceData&& e) : IfcEdge(std::move(e)) { }
Ifc2x3::IfcEdgeCurve::IfcEdgeCurve(::Ifc2x3::IfcVertex* v1_EdgeStart, ::Ifc2x3::IfcVertex* v2_EdgeEnd, ::Ifc2x3::IfcCurve* v3_EdgeGeometry, bool v4_SameSense) : IfcEdge(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_EdgeStart ? v1_EdgeStart->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_EdgeEnd ? v2_EdgeEnd->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_EdgeGeometry ? v3_EdgeGeometry->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_SameSense));; populate_derived(); }

// Function implementations for IfcEdgeFeature
boost::optional< double > Ifc2x3::IfcEdgeFeature::FeatureLength() const { if(get_attribute_value(8).isNull()) { return boost::none; } double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcEdgeFeature::setFeatureLength(boost::optional< double > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }


const IfcParse::entity& Ifc2x3::IfcEdgeFeature::declaration() const { return *((IfcParse::entity*)IFC2X3_types[271]); }
const IfcParse::entity& Ifc2x3::IfcEdgeFeature::Class() { return *((IfcParse::entity*)IFC2X3_types[271]); }
Ifc2x3::IfcEdgeFeature::IfcEdgeFeature(IfcEntityInstanceData&& e) : IfcFeatureElementSubtraction(std::move(e)) { }
Ifc2x3::IfcEdgeFeature::IfcEdgeFeature(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_FeatureLength) : IfcFeatureElementSubtraction(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_FeatureLength) {set_attribute_value(8, (*v9_FeatureLength)); }; populate_derived(); }

// Function implementations for IfcEdgeLoop
aggregate_of< ::Ifc2x3::IfcOrientedEdge >::ptr Ifc2x3::IfcEdgeLoop::EdgeList() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcOrientedEdge >(); }
void Ifc2x3::IfcEdgeLoop::setEdgeList(aggregate_of< ::Ifc2x3::IfcOrientedEdge >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcEdgeLoop::declaration() const { return *((IfcParse::entity*)IFC2X3_types[272]); }
const IfcParse::entity& Ifc2x3::IfcEdgeLoop::Class() { return *((IfcParse::entity*)IFC2X3_types[272]); }
Ifc2x3::IfcEdgeLoop::IfcEdgeLoop(IfcEntityInstanceData&& e) : IfcLoop(std::move(e)) { }
Ifc2x3::IfcEdgeLoop::IfcEdgeLoop(aggregate_of< ::Ifc2x3::IfcOrientedEdge >::ptr v1_EdgeList) : IfcLoop(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_EdgeList)->generalize());; populate_derived(); }

// Function implementations for IfcElectricApplianceType
::Ifc2x3::IfcElectricApplianceTypeEnum::Value Ifc2x3::IfcElectricApplianceType::PredefinedType() const {  return ::Ifc2x3::IfcElectricApplianceTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcElectricApplianceType::setPredefinedType(::Ifc2x3::IfcElectricApplianceTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcElectricApplianceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcElectricApplianceType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[276]); }
const IfcParse::entity& Ifc2x3::IfcElectricApplianceType::Class() { return *((IfcParse::entity*)IFC2X3_types[276]); }
Ifc2x3::IfcElectricApplianceType::IfcElectricApplianceType(IfcEntityInstanceData&& e) : IfcFlowTerminalType(std::move(e)) { }
Ifc2x3::IfcElectricApplianceType::IfcElectricApplianceType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcElectricApplianceTypeEnum::Value v10_PredefinedType) : IfcFlowTerminalType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcElectricApplianceTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcElectricDistributionPoint
::Ifc2x3::IfcElectricDistributionPointFunctionEnum::Value Ifc2x3::IfcElectricDistributionPoint::DistributionPointFunction() const {  return ::Ifc2x3::IfcElectricDistributionPointFunctionEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcElectricDistributionPoint::setDistributionPointFunction(::Ifc2x3::IfcElectricDistributionPointFunctionEnum::Value v) { set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcElectricDistributionPointFunctionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }
boost::optional< std::string > Ifc2x3::IfcElectricDistributionPoint::UserDefinedFunction() const { if(get_attribute_value(9).isNull()) { return boost::none; } std::string v = get_attribute_value(9); return v; }
void Ifc2x3::IfcElectricDistributionPoint::setUserDefinedFunction(boost::optional< std::string > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }


const IfcParse::entity& Ifc2x3::IfcElectricDistributionPoint::declaration() const { return *((IfcParse::entity*)IFC2X3_types[283]); }
const IfcParse::entity& Ifc2x3::IfcElectricDistributionPoint::Class() { return *((IfcParse::entity*)IFC2X3_types[283]); }
Ifc2x3::IfcElectricDistributionPoint::IfcElectricDistributionPoint(IfcEntityInstanceData&& e) : IfcFlowController(std::move(e)) { }
Ifc2x3::IfcElectricDistributionPoint::IfcElectricDistributionPoint(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, ::Ifc2x3::IfcElectricDistributionPointFunctionEnum::Value v9_DistributionPointFunction, boost::optional< std::string > v10_UserDefinedFunction) : IfcFlowController(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcElectricDistributionPointFunctionEnum::Class(),(size_t)v9_DistributionPointFunction))); if (v10_UserDefinedFunction) {set_attribute_value(9, (*v10_UserDefinedFunction)); }; populate_derived(); }

// Function implementations for IfcElectricFlowStorageDeviceType
::Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::Value Ifc2x3::IfcElectricFlowStorageDeviceType::PredefinedType() const {  return ::Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcElectricFlowStorageDeviceType::setPredefinedType(::Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcElectricFlowStorageDeviceType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[285]); }
const IfcParse::entity& Ifc2x3::IfcElectricFlowStorageDeviceType::Class() { return *((IfcParse::entity*)IFC2X3_types[285]); }
Ifc2x3::IfcElectricFlowStorageDeviceType::IfcElectricFlowStorageDeviceType(IfcEntityInstanceData&& e) : IfcFlowStorageDeviceType(std::move(e)) { }
Ifc2x3::IfcElectricFlowStorageDeviceType::IfcElectricFlowStorageDeviceType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::Value v10_PredefinedType) : IfcFlowStorageDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcElectricFlowStorageDeviceTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcElectricGeneratorType
::Ifc2x3::IfcElectricGeneratorTypeEnum::Value Ifc2x3::IfcElectricGeneratorType::PredefinedType() const {  return ::Ifc2x3::IfcElectricGeneratorTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcElectricGeneratorType::setPredefinedType(::Ifc2x3::IfcElectricGeneratorTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcElectricGeneratorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcElectricGeneratorType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[287]); }
const IfcParse::entity& Ifc2x3::IfcElectricGeneratorType::Class() { return *((IfcParse::entity*)IFC2X3_types[287]); }
Ifc2x3::IfcElectricGeneratorType::IfcElectricGeneratorType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcElectricGeneratorType::IfcElectricGeneratorType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcElectricGeneratorTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcElectricGeneratorTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcElectricHeaterType
::Ifc2x3::IfcElectricHeaterTypeEnum::Value Ifc2x3::IfcElectricHeaterType::PredefinedType() const {  return ::Ifc2x3::IfcElectricHeaterTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcElectricHeaterType::setPredefinedType(::Ifc2x3::IfcElectricHeaterTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcElectricHeaterTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcElectricHeaterType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[289]); }
const IfcParse::entity& Ifc2x3::IfcElectricHeaterType::Class() { return *((IfcParse::entity*)IFC2X3_types[289]); }
Ifc2x3::IfcElectricHeaterType::IfcElectricHeaterType(IfcEntityInstanceData&& e) : IfcFlowTerminalType(std::move(e)) { }
Ifc2x3::IfcElectricHeaterType::IfcElectricHeaterType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcElectricHeaterTypeEnum::Value v10_PredefinedType) : IfcFlowTerminalType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcElectricHeaterTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcElectricMotorType
::Ifc2x3::IfcElectricMotorTypeEnum::Value Ifc2x3::IfcElectricMotorType::PredefinedType() const {  return ::Ifc2x3::IfcElectricMotorTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcElectricMotorType::setPredefinedType(::Ifc2x3::IfcElectricMotorTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcElectricMotorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcElectricMotorType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[291]); }
const IfcParse::entity& Ifc2x3::IfcElectricMotorType::Class() { return *((IfcParse::entity*)IFC2X3_types[291]); }
Ifc2x3::IfcElectricMotorType::IfcElectricMotorType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcElectricMotorType::IfcElectricMotorType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcElectricMotorTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcElectricMotorTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcElectricTimeControlType
::Ifc2x3::IfcElectricTimeControlTypeEnum::Value Ifc2x3::IfcElectricTimeControlType::PredefinedType() const {  return ::Ifc2x3::IfcElectricTimeControlTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcElectricTimeControlType::setPredefinedType(::Ifc2x3::IfcElectricTimeControlTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcElectricTimeControlTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcElectricTimeControlType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[294]); }
const IfcParse::entity& Ifc2x3::IfcElectricTimeControlType::Class() { return *((IfcParse::entity*)IFC2X3_types[294]); }
Ifc2x3::IfcElectricTimeControlType::IfcElectricTimeControlType(IfcEntityInstanceData&& e) : IfcFlowControllerType(std::move(e)) { }
Ifc2x3::IfcElectricTimeControlType::IfcElectricTimeControlType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcElectricTimeControlTypeEnum::Value v10_PredefinedType) : IfcFlowControllerType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcElectricTimeControlTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcElectricalBaseProperties
boost::optional< ::Ifc2x3::IfcElectricCurrentEnum::Value > Ifc2x3::IfcElectricalBaseProperties::ElectricCurrentType() const { if(get_attribute_value(6).isNull()) { return boost::none; } return ::Ifc2x3::IfcElectricCurrentEnum::FromString(get_attribute_value(6)); }
void Ifc2x3::IfcElectricalBaseProperties::setElectricCurrentType(boost::optional< ::Ifc2x3::IfcElectricCurrentEnum::Value > v) { if (v) {set_attribute_value(6, EnumerationReference(&::Ifc2x3::IfcElectricCurrentEnum::Class(), (size_t) *v));} else {unset_attribute_value(6);} }
double Ifc2x3::IfcElectricalBaseProperties::InputVoltage() const {  double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcElectricalBaseProperties::setInputVoltage(double v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
double Ifc2x3::IfcElectricalBaseProperties::InputFrequency() const {  double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcElectricalBaseProperties::setInputFrequency(double v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
boost::optional< double > Ifc2x3::IfcElectricalBaseProperties::FullLoadCurrent() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcElectricalBaseProperties::setFullLoadCurrent(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
boost::optional< double > Ifc2x3::IfcElectricalBaseProperties::MinimumCircuitCurrent() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcElectricalBaseProperties::setMinimumCircuitCurrent(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
boost::optional< double > Ifc2x3::IfcElectricalBaseProperties::MaximumPowerInput() const { if(get_attribute_value(11).isNull()) { return boost::none; } double v = get_attribute_value(11); return v; }
void Ifc2x3::IfcElectricalBaseProperties::setMaximumPowerInput(boost::optional< double > v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
boost::optional< double > Ifc2x3::IfcElectricalBaseProperties::RatedPowerInput() const { if(get_attribute_value(12).isNull()) { return boost::none; } double v = get_attribute_value(12); return v; }
void Ifc2x3::IfcElectricalBaseProperties::setRatedPowerInput(boost::optional< double > v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
int Ifc2x3::IfcElectricalBaseProperties::InputPhase() const {  int v = get_attribute_value(13); return v; }
void Ifc2x3::IfcElectricalBaseProperties::setInputPhase(int v) { set_attribute_value(13, v);if constexpr (false)unset_attribute_value(13); }


const IfcParse::entity& Ifc2x3::IfcElectricalBaseProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[273]); }
const IfcParse::entity& Ifc2x3::IfcElectricalBaseProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[273]); }
Ifc2x3::IfcElectricalBaseProperties::IfcElectricalBaseProperties(IfcEntityInstanceData&& e) : IfcEnergyProperties(std::move(e)) { }
Ifc2x3::IfcElectricalBaseProperties::IfcElectricalBaseProperties(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< ::Ifc2x3::IfcEnergySequenceEnum::Value > v5_EnergySequence, boost::optional< std::string > v6_UserDefinedEnergySequence, boost::optional< ::Ifc2x3::IfcElectricCurrentEnum::Value > v7_ElectricCurrentType, double v8_InputVoltage, double v9_InputFrequency, boost::optional< double > v10_FullLoadCurrent, boost::optional< double > v11_MinimumCircuitCurrent, boost::optional< double > v12_MaximumPowerInput, boost::optional< double > v13_RatedPowerInput, int v14_InputPhase) : IfcEnergyProperties(IfcEntityInstanceData(in_memory_attribute_storage(14))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_EnergySequence) {set_attribute_value(4, (EnumerationReference(&::Ifc2x3::IfcEnergySequenceEnum::Class(),(size_t)*v5_EnergySequence))); } if (v6_UserDefinedEnergySequence) {set_attribute_value(5, (*v6_UserDefinedEnergySequence)); } if (v7_ElectricCurrentType) {set_attribute_value(6, (EnumerationReference(&::Ifc2x3::IfcElectricCurrentEnum::Class(),(size_t)*v7_ElectricCurrentType))); }set_attribute_value(7, (v8_InputVoltage));set_attribute_value(8, (v9_InputFrequency)); if (v10_FullLoadCurrent) {set_attribute_value(9, (*v10_FullLoadCurrent)); } if (v11_MinimumCircuitCurrent) {set_attribute_value(10, (*v11_MinimumCircuitCurrent)); } if (v12_MaximumPowerInput) {set_attribute_value(11, (*v12_MaximumPowerInput)); } if (v13_RatedPowerInput) {set_attribute_value(12, (*v13_RatedPowerInput)); }set_attribute_value(13, (v14_InputPhase));; populate_derived(); }

// Function implementations for IfcElectricalCircuit


const IfcParse::entity& Ifc2x3::IfcElectricalCircuit::declaration() const { return *((IfcParse::entity*)IFC2X3_types[274]); }
const IfcParse::entity& Ifc2x3::IfcElectricalCircuit::Class() { return *((IfcParse::entity*)IFC2X3_types[274]); }
Ifc2x3::IfcElectricalCircuit::IfcElectricalCircuit(IfcEntityInstanceData&& e) : IfcSystem(std::move(e)) { }
Ifc2x3::IfcElectricalCircuit::IfcElectricalCircuit(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcSystem(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }; populate_derived(); }

// Function implementations for IfcElectricalElement


const IfcParse::entity& Ifc2x3::IfcElectricalElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[275]); }
const IfcParse::entity& Ifc2x3::IfcElectricalElement::Class() { return *((IfcParse::entity*)IFC2X3_types[275]); }
Ifc2x3::IfcElectricalElement::IfcElectricalElement(IfcEntityInstanceData&& e) : IfcElement(std::move(e)) { }
Ifc2x3::IfcElectricalElement::IfcElectricalElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcElement
boost::optional< std::string > Ifc2x3::IfcElement::Tag() const { if(get_attribute_value(7).isNull()) { return boost::none; } std::string v = get_attribute_value(7); return v; }
void Ifc2x3::IfcElement::setTag(boost::optional< std::string > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }

::Ifc2x3::IfcRelConnectsStructuralElement::list::ptr Ifc2x3::IfcElement::HasStructuralMember() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[694], 4)->as<IfcRelConnectsStructuralElement>(); }
::Ifc2x3::IfcRelFillsElement::list::ptr Ifc2x3::IfcElement::FillsVoids() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[705], 5)->as<IfcRelFillsElement>(); }
::Ifc2x3::IfcRelConnectsElements::list::ptr Ifc2x3::IfcElement::ConnectedTo() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[689], 5)->as<IfcRelConnectsElements>(); }
::Ifc2x3::IfcRelCoversBldgElements::list::ptr Ifc2x3::IfcElement::HasCoverings() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[699], 4)->as<IfcRelCoversBldgElements>(); }
::Ifc2x3::IfcRelProjectsElement::list::ptr Ifc2x3::IfcElement::HasProjections() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[711], 4)->as<IfcRelProjectsElement>(); }
::Ifc2x3::IfcRelReferencedInSpatialStructure::list::ptr Ifc2x3::IfcElement::ReferencedInStructures() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[712], 4)->as<IfcRelReferencedInSpatialStructure>(); }
::Ifc2x3::IfcRelConnectsPortToElement::list::ptr Ifc2x3::IfcElement::HasPorts() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[692], 5)->as<IfcRelConnectsPortToElement>(); }
::Ifc2x3::IfcRelVoidsElement::list::ptr Ifc2x3::IfcElement::HasOpenings() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[717], 4)->as<IfcRelVoidsElement>(); }
::Ifc2x3::IfcRelConnectsWithRealizingElements::list::ptr Ifc2x3::IfcElement::IsConnectionRealization() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[697], 7)->as<IfcRelConnectsWithRealizingElements>(); }
::Ifc2x3::IfcRelSpaceBoundary::list::ptr Ifc2x3::IfcElement::ProvidesBoundaries() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[716], 5)->as<IfcRelSpaceBoundary>(); }
::Ifc2x3::IfcRelConnectsElements::list::ptr Ifc2x3::IfcElement::ConnectedFrom() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[689], 6)->as<IfcRelConnectsElements>(); }
::Ifc2x3::IfcRelContainedInSpatialStructure::list::ptr Ifc2x3::IfcElement::ContainedInStructure() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[698], 4)->as<IfcRelContainedInSpatialStructure>(); }

const IfcParse::entity& Ifc2x3::IfcElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[297]); }
const IfcParse::entity& Ifc2x3::IfcElement::Class() { return *((IfcParse::entity*)IFC2X3_types[297]); }
Ifc2x3::IfcElement::IfcElement(IfcEntityInstanceData&& e) : IfcProduct(std::move(e)) { }
Ifc2x3::IfcElement::IfcElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcProduct(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcElementAssembly
boost::optional< ::Ifc2x3::IfcAssemblyPlaceEnum::Value > Ifc2x3::IfcElementAssembly::AssemblyPlace() const { if(get_attribute_value(8).isNull()) { return boost::none; } return ::Ifc2x3::IfcAssemblyPlaceEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcElementAssembly::setAssemblyPlace(boost::optional< ::Ifc2x3::IfcAssemblyPlaceEnum::Value > v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcAssemblyPlaceEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
::Ifc2x3::IfcElementAssemblyTypeEnum::Value Ifc2x3::IfcElementAssembly::PredefinedType() const {  return ::Ifc2x3::IfcElementAssemblyTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcElementAssembly::setPredefinedType(::Ifc2x3::IfcElementAssemblyTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcElementAssemblyTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcElementAssembly::declaration() const { return *((IfcParse::entity*)IFC2X3_types[299]); }
const IfcParse::entity& Ifc2x3::IfcElementAssembly::Class() { return *((IfcParse::entity*)IFC2X3_types[299]); }
Ifc2x3::IfcElementAssembly::IfcElementAssembly(IfcEntityInstanceData&& e) : IfcElement(std::move(e)) { }
Ifc2x3::IfcElementAssembly::IfcElementAssembly(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< ::Ifc2x3::IfcAssemblyPlaceEnum::Value > v9_AssemblyPlace, ::Ifc2x3::IfcElementAssemblyTypeEnum::Value v10_PredefinedType) : IfcElement(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_AssemblyPlace) {set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcAssemblyPlaceEnum::Class(),(size_t)*v9_AssemblyPlace))); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcElementAssemblyTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcElementComponent


const IfcParse::entity& Ifc2x3::IfcElementComponent::declaration() const { return *((IfcParse::entity*)IFC2X3_types[301]); }
const IfcParse::entity& Ifc2x3::IfcElementComponent::Class() { return *((IfcParse::entity*)IFC2X3_types[301]); }
Ifc2x3::IfcElementComponent::IfcElementComponent(IfcEntityInstanceData&& e) : IfcElement(std::move(e)) { }
Ifc2x3::IfcElementComponent::IfcElementComponent(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcElementComponentType


const IfcParse::entity& Ifc2x3::IfcElementComponentType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[302]); }
const IfcParse::entity& Ifc2x3::IfcElementComponentType::Class() { return *((IfcParse::entity*)IFC2X3_types[302]); }
Ifc2x3::IfcElementComponentType::IfcElementComponentType(IfcEntityInstanceData&& e) : IfcElementType(std::move(e)) { }
Ifc2x3::IfcElementComponentType::IfcElementComponentType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcElementQuantity
boost::optional< std::string > Ifc2x3::IfcElementQuantity::MethodOfMeasurement() const { if(get_attribute_value(4).isNull()) { return boost::none; } std::string v = get_attribute_value(4); return v; }
void Ifc2x3::IfcElementQuantity::setMethodOfMeasurement(boost::optional< std::string > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
aggregate_of< ::Ifc2x3::IfcPhysicalQuantity >::ptr Ifc2x3::IfcElementQuantity::Quantities() const {  aggregate_of_instance::ptr es = get_attribute_value(5); return es->as< ::Ifc2x3::IfcPhysicalQuantity >(); }
void Ifc2x3::IfcElementQuantity::setQuantities(aggregate_of< ::Ifc2x3::IfcPhysicalQuantity >::ptr v) { set_attribute_value(5, (v)->generalize());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcElementQuantity::declaration() const { return *((IfcParse::entity*)IFC2X3_types[304]); }
const IfcParse::entity& Ifc2x3::IfcElementQuantity::Class() { return *((IfcParse::entity*)IFC2X3_types[304]); }
Ifc2x3::IfcElementQuantity::IfcElementQuantity(IfcEntityInstanceData&& e) : IfcPropertySetDefinition(std::move(e)) { }
Ifc2x3::IfcElementQuantity::IfcElementQuantity(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_MethodOfMeasurement, aggregate_of< ::Ifc2x3::IfcPhysicalQuantity >::ptr v6_Quantities) : IfcPropertySetDefinition(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_MethodOfMeasurement) {set_attribute_value(4, (*v5_MethodOfMeasurement)); }set_attribute_value(5, (v6_Quantities)->generalize());; populate_derived(); }

// Function implementations for IfcElementType
boost::optional< std::string > Ifc2x3::IfcElementType::ElementType() const { if(get_attribute_value(8).isNull()) { return boost::none; } std::string v = get_attribute_value(8); return v; }
void Ifc2x3::IfcElementType::setElementType(boost::optional< std::string > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }


const IfcParse::entity& Ifc2x3::IfcElementType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[305]); }
const IfcParse::entity& Ifc2x3::IfcElementType::Class() { return *((IfcParse::entity*)IFC2X3_types[305]); }
Ifc2x3::IfcElementType::IfcElementType(IfcEntityInstanceData&& e) : IfcTypeProduct(std::move(e)) { }
Ifc2x3::IfcElementType::IfcElementType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcTypeProduct(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcElementarySurface
::Ifc2x3::IfcAxis2Placement3D* Ifc2x3::IfcElementarySurface::Position() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcAxis2Placement3D>(true); }
void Ifc2x3::IfcElementarySurface::setPosition(::Ifc2x3::IfcAxis2Placement3D* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcElementarySurface::declaration() const { return *((IfcParse::entity*)IFC2X3_types[298]); }
const IfcParse::entity& Ifc2x3::IfcElementarySurface::Class() { return *((IfcParse::entity*)IFC2X3_types[298]); }
Ifc2x3::IfcElementarySurface::IfcElementarySurface(IfcEntityInstanceData&& e) : IfcSurface(std::move(e)) { }
Ifc2x3::IfcElementarySurface::IfcElementarySurface(::Ifc2x3::IfcAxis2Placement3D* v1_Position) : IfcSurface(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, v1_Position ? v1_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcEllipse
double Ifc2x3::IfcEllipse::SemiAxis1() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcEllipse::setSemiAxis1(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
double Ifc2x3::IfcEllipse::SemiAxis2() const {  double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcEllipse::setSemiAxis2(double v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcEllipse::declaration() const { return *((IfcParse::entity*)IFC2X3_types[306]); }
const IfcParse::entity& Ifc2x3::IfcEllipse::Class() { return *((IfcParse::entity*)IFC2X3_types[306]); }
Ifc2x3::IfcEllipse::IfcEllipse(IfcEntityInstanceData&& e) : IfcConic(std::move(e)) { }
Ifc2x3::IfcEllipse::IfcEllipse(::Ifc2x3::IfcAxis2Placement* v1_Position, double v2_SemiAxis1, double v3_SemiAxis2) : IfcConic(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_Position ? v1_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_SemiAxis1));set_attribute_value(2, (v3_SemiAxis2));; populate_derived(); }

// Function implementations for IfcEllipseProfileDef
double Ifc2x3::IfcEllipseProfileDef::SemiAxis1() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcEllipseProfileDef::setSemiAxis1(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
double Ifc2x3::IfcEllipseProfileDef::SemiAxis2() const {  double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcEllipseProfileDef::setSemiAxis2(double v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcEllipseProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[307]); }
const IfcParse::entity& Ifc2x3::IfcEllipseProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[307]); }
Ifc2x3::IfcEllipseProfileDef::IfcEllipseProfileDef(IfcEntityInstanceData&& e) : IfcParameterizedProfileDef(std::move(e)) { }
Ifc2x3::IfcEllipseProfileDef::IfcEllipseProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcAxis2Placement2D* v3_Position, double v4_SemiAxis1, double v5_SemiAxis2) : IfcParameterizedProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_SemiAxis1));set_attribute_value(4, (v5_SemiAxis2));; populate_derived(); }

// Function implementations for IfcEnergyConversionDevice


const IfcParse::entity& Ifc2x3::IfcEnergyConversionDevice::declaration() const { return *((IfcParse::entity*)IFC2X3_types[308]); }
const IfcParse::entity& Ifc2x3::IfcEnergyConversionDevice::Class() { return *((IfcParse::entity*)IFC2X3_types[308]); }
Ifc2x3::IfcEnergyConversionDevice::IfcEnergyConversionDevice(IfcEntityInstanceData&& e) : IfcDistributionFlowElement(std::move(e)) { }
Ifc2x3::IfcEnergyConversionDevice::IfcEnergyConversionDevice(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcEnergyConversionDeviceType


const IfcParse::entity& Ifc2x3::IfcEnergyConversionDeviceType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[309]); }
const IfcParse::entity& Ifc2x3::IfcEnergyConversionDeviceType::Class() { return *((IfcParse::entity*)IFC2X3_types[309]); }
Ifc2x3::IfcEnergyConversionDeviceType::IfcEnergyConversionDeviceType(IfcEntityInstanceData&& e) : IfcDistributionFlowElementType(std::move(e)) { }
Ifc2x3::IfcEnergyConversionDeviceType::IfcEnergyConversionDeviceType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcEnergyProperties
boost::optional< ::Ifc2x3::IfcEnergySequenceEnum::Value > Ifc2x3::IfcEnergyProperties::EnergySequence() const { if(get_attribute_value(4).isNull()) { return boost::none; } return ::Ifc2x3::IfcEnergySequenceEnum::FromString(get_attribute_value(4)); }
void Ifc2x3::IfcEnergyProperties::setEnergySequence(boost::optional< ::Ifc2x3::IfcEnergySequenceEnum::Value > v) { if (v) {set_attribute_value(4, EnumerationReference(&::Ifc2x3::IfcEnergySequenceEnum::Class(), (size_t) *v));} else {unset_attribute_value(4);} }
boost::optional< std::string > Ifc2x3::IfcEnergyProperties::UserDefinedEnergySequence() const { if(get_attribute_value(5).isNull()) { return boost::none; } std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcEnergyProperties::setUserDefinedEnergySequence(boost::optional< std::string > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }


const IfcParse::entity& Ifc2x3::IfcEnergyProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[311]); }
const IfcParse::entity& Ifc2x3::IfcEnergyProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[311]); }
Ifc2x3::IfcEnergyProperties::IfcEnergyProperties(IfcEntityInstanceData&& e) : IfcPropertySetDefinition(std::move(e)) { }
Ifc2x3::IfcEnergyProperties::IfcEnergyProperties(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< ::Ifc2x3::IfcEnergySequenceEnum::Value > v5_EnergySequence, boost::optional< std::string > v6_UserDefinedEnergySequence) : IfcPropertySetDefinition(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_EnergySequence) {set_attribute_value(4, (EnumerationReference(&::Ifc2x3::IfcEnergySequenceEnum::Class(),(size_t)*v5_EnergySequence))); } if (v6_UserDefinedEnergySequence) {set_attribute_value(5, (*v6_UserDefinedEnergySequence)); }; populate_derived(); }

// Function implementations for IfcEnvironmentalImpactValue
std::string Ifc2x3::IfcEnvironmentalImpactValue::ImpactType() const {  std::string v = get_attribute_value(6); return v; }
void Ifc2x3::IfcEnvironmentalImpactValue::setImpactType(std::string v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
::Ifc2x3::IfcEnvironmentalImpactCategoryEnum::Value Ifc2x3::IfcEnvironmentalImpactValue::Category() const {  return ::Ifc2x3::IfcEnvironmentalImpactCategoryEnum::FromString(get_attribute_value(7)); }
void Ifc2x3::IfcEnvironmentalImpactValue::setCategory(::Ifc2x3::IfcEnvironmentalImpactCategoryEnum::Value v) { set_attribute_value(7, EnumerationReference(&::Ifc2x3::IfcEnvironmentalImpactCategoryEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }
boost::optional< std::string > Ifc2x3::IfcEnvironmentalImpactValue::UserDefinedCategory() const { if(get_attribute_value(8).isNull()) { return boost::none; } std::string v = get_attribute_value(8); return v; }
void Ifc2x3::IfcEnvironmentalImpactValue::setUserDefinedCategory(boost::optional< std::string > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }


const IfcParse::entity& Ifc2x3::IfcEnvironmentalImpactValue::declaration() const { return *((IfcParse::entity*)IFC2X3_types[314]); }
const IfcParse::entity& Ifc2x3::IfcEnvironmentalImpactValue::Class() { return *((IfcParse::entity*)IFC2X3_types[314]); }
Ifc2x3::IfcEnvironmentalImpactValue::IfcEnvironmentalImpactValue(IfcEntityInstanceData&& e) : IfcAppliedValue(std::move(e)) { }
Ifc2x3::IfcEnvironmentalImpactValue::IfcEnvironmentalImpactValue(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcAppliedValueSelect* v3_AppliedValue, ::Ifc2x3::IfcMeasureWithUnit* v4_UnitBasis, ::Ifc2x3::IfcDateTimeSelect* v5_ApplicableDate, ::Ifc2x3::IfcDateTimeSelect* v6_FixedUntilDate, std::string v7_ImpactType, ::Ifc2x3::IfcEnvironmentalImpactCategoryEnum::Value v8_Category, boost::optional< std::string > v9_UserDefinedCategory) : IfcAppliedValue(IfcEntityInstanceData(in_memory_attribute_storage(9))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_AppliedValue ? v3_AppliedValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_UnitBasis ? v4_UnitBasis->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(4, v5_ApplicableDate ? v5_ApplicableDate->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_FixedUntilDate ? v6_FixedUntilDate->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, (v7_ImpactType));set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcEnvironmentalImpactCategoryEnum::Class(),(size_t)v8_Category))); if (v9_UserDefinedCategory) {set_attribute_value(8, (*v9_UserDefinedCategory)); }; populate_derived(); }

// Function implementations for IfcEquipmentElement


const IfcParse::entity& Ifc2x3::IfcEquipmentElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[315]); }
const IfcParse::entity& Ifc2x3::IfcEquipmentElement::Class() { return *((IfcParse::entity*)IFC2X3_types[315]); }
Ifc2x3::IfcEquipmentElement::IfcEquipmentElement(IfcEntityInstanceData&& e) : IfcElement(std::move(e)) { }
Ifc2x3::IfcEquipmentElement::IfcEquipmentElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcEquipmentStandard


const IfcParse::entity& Ifc2x3::IfcEquipmentStandard::declaration() const { return *((IfcParse::entity*)IFC2X3_types[316]); }
const IfcParse::entity& Ifc2x3::IfcEquipmentStandard::Class() { return *((IfcParse::entity*)IFC2X3_types[316]); }
Ifc2x3::IfcEquipmentStandard::IfcEquipmentStandard(IfcEntityInstanceData&& e) : IfcControl(std::move(e)) { }
Ifc2x3::IfcEquipmentStandard::IfcEquipmentStandard(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcControl(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }; populate_derived(); }

// Function implementations for IfcEvaporativeCoolerType
::Ifc2x3::IfcEvaporativeCoolerTypeEnum::Value Ifc2x3::IfcEvaporativeCoolerType::PredefinedType() const {  return ::Ifc2x3::IfcEvaporativeCoolerTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcEvaporativeCoolerType::setPredefinedType(::Ifc2x3::IfcEvaporativeCoolerTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcEvaporativeCoolerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcEvaporativeCoolerType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[317]); }
const IfcParse::entity& Ifc2x3::IfcEvaporativeCoolerType::Class() { return *((IfcParse::entity*)IFC2X3_types[317]); }
Ifc2x3::IfcEvaporativeCoolerType::IfcEvaporativeCoolerType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcEvaporativeCoolerType::IfcEvaporativeCoolerType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcEvaporativeCoolerTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcEvaporativeCoolerTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcEvaporatorType
::Ifc2x3::IfcEvaporatorTypeEnum::Value Ifc2x3::IfcEvaporatorType::PredefinedType() const {  return ::Ifc2x3::IfcEvaporatorTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcEvaporatorType::setPredefinedType(::Ifc2x3::IfcEvaporatorTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcEvaporatorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcEvaporatorType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[319]); }
const IfcParse::entity& Ifc2x3::IfcEvaporatorType::Class() { return *((IfcParse::entity*)IFC2X3_types[319]); }
Ifc2x3::IfcEvaporatorType::IfcEvaporatorType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcEvaporatorType::IfcEvaporatorType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcEvaporatorTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcEvaporatorTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcExtendedMaterialProperties
aggregate_of< ::Ifc2x3::IfcProperty >::ptr Ifc2x3::IfcExtendedMaterialProperties::ExtendedProperties() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcProperty >(); }
void Ifc2x3::IfcExtendedMaterialProperties::setExtendedProperties(aggregate_of< ::Ifc2x3::IfcProperty >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }
boost::optional< std::string > Ifc2x3::IfcExtendedMaterialProperties::Description() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcExtendedMaterialProperties::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
std::string Ifc2x3::IfcExtendedMaterialProperties::Name() const {  std::string v = get_attribute_value(3); return v; }
void Ifc2x3::IfcExtendedMaterialProperties::setName(std::string v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcExtendedMaterialProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[321]); }
const IfcParse::entity& Ifc2x3::IfcExtendedMaterialProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[321]); }
Ifc2x3::IfcExtendedMaterialProperties::IfcExtendedMaterialProperties(IfcEntityInstanceData&& e) : IfcMaterialProperties(std::move(e)) { }
Ifc2x3::IfcExtendedMaterialProperties::IfcExtendedMaterialProperties(::Ifc2x3::IfcMaterial* v1_Material, aggregate_of< ::Ifc2x3::IfcProperty >::ptr v2_ExtendedProperties, boost::optional< std::string > v3_Description, std::string v4_Name) : IfcMaterialProperties(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_Material ? v1_Material->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_ExtendedProperties)->generalize()); if (v3_Description) {set_attribute_value(2, (*v3_Description)); }set_attribute_value(3, (v4_Name));; populate_derived(); }

// Function implementations for IfcExternalReference
boost::optional< std::string > Ifc2x3::IfcExternalReference::Location() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcExternalReference::setLocation(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
boost::optional< std::string > Ifc2x3::IfcExternalReference::ItemReference() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcExternalReference::setItemReference(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< std::string > Ifc2x3::IfcExternalReference::Name() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcExternalReference::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }


const IfcParse::entity& Ifc2x3::IfcExternalReference::declaration() const { return *((IfcParse::entity*)IFC2X3_types[326]); }
const IfcParse::entity& Ifc2x3::IfcExternalReference::Class() { return *((IfcParse::entity*)IFC2X3_types[326]); }
Ifc2x3::IfcExternalReference::IfcExternalReference(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcExternalReference::IfcExternalReference(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) {  if (v1_Location) {set_attribute_value(0, (*v1_Location)); } if (v2_ItemReference) {set_attribute_value(1, (*v2_ItemReference)); } if (v3_Name) {set_attribute_value(2, (*v3_Name)); }; populate_derived(); }

// Function implementations for IfcExternallyDefinedHatchStyle


const IfcParse::entity& Ifc2x3::IfcExternallyDefinedHatchStyle::declaration() const { return *((IfcParse::entity*)IFC2X3_types[322]); }
const IfcParse::entity& Ifc2x3::IfcExternallyDefinedHatchStyle::Class() { return *((IfcParse::entity*)IFC2X3_types[322]); }
Ifc2x3::IfcExternallyDefinedHatchStyle::IfcExternallyDefinedHatchStyle(IfcEntityInstanceData&& e) : IfcExternalReference(std::move(e)) { }
Ifc2x3::IfcExternallyDefinedHatchStyle::IfcExternallyDefinedHatchStyle(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference(IfcEntityInstanceData(in_memory_attribute_storage(3))) {  if (v1_Location) {set_attribute_value(0, (*v1_Location)); } if (v2_ItemReference) {set_attribute_value(1, (*v2_ItemReference)); } if (v3_Name) {set_attribute_value(2, (*v3_Name)); }; populate_derived(); }

// Function implementations for IfcExternallyDefinedSurfaceStyle


const IfcParse::entity& Ifc2x3::IfcExternallyDefinedSurfaceStyle::declaration() const { return *((IfcParse::entity*)IFC2X3_types[323]); }
const IfcParse::entity& Ifc2x3::IfcExternallyDefinedSurfaceStyle::Class() { return *((IfcParse::entity*)IFC2X3_types[323]); }
Ifc2x3::IfcExternallyDefinedSurfaceStyle::IfcExternallyDefinedSurfaceStyle(IfcEntityInstanceData&& e) : IfcExternalReference(std::move(e)) { }
Ifc2x3::IfcExternallyDefinedSurfaceStyle::IfcExternallyDefinedSurfaceStyle(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference(IfcEntityInstanceData(in_memory_attribute_storage(3))) {  if (v1_Location) {set_attribute_value(0, (*v1_Location)); } if (v2_ItemReference) {set_attribute_value(1, (*v2_ItemReference)); } if (v3_Name) {set_attribute_value(2, (*v3_Name)); }; populate_derived(); }

// Function implementations for IfcExternallyDefinedSymbol


const IfcParse::entity& Ifc2x3::IfcExternallyDefinedSymbol::declaration() const { return *((IfcParse::entity*)IFC2X3_types[324]); }
const IfcParse::entity& Ifc2x3::IfcExternallyDefinedSymbol::Class() { return *((IfcParse::entity*)IFC2X3_types[324]); }
Ifc2x3::IfcExternallyDefinedSymbol::IfcExternallyDefinedSymbol(IfcEntityInstanceData&& e) : IfcExternalReference(std::move(e)) { }
Ifc2x3::IfcExternallyDefinedSymbol::IfcExternallyDefinedSymbol(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference(IfcEntityInstanceData(in_memory_attribute_storage(3))) {  if (v1_Location) {set_attribute_value(0, (*v1_Location)); } if (v2_ItemReference) {set_attribute_value(1, (*v2_ItemReference)); } if (v3_Name) {set_attribute_value(2, (*v3_Name)); }; populate_derived(); }

// Function implementations for IfcExternallyDefinedTextFont


const IfcParse::entity& Ifc2x3::IfcExternallyDefinedTextFont::declaration() const { return *((IfcParse::entity*)IFC2X3_types[325]); }
const IfcParse::entity& Ifc2x3::IfcExternallyDefinedTextFont::Class() { return *((IfcParse::entity*)IFC2X3_types[325]); }
Ifc2x3::IfcExternallyDefinedTextFont::IfcExternallyDefinedTextFont(IfcEntityInstanceData&& e) : IfcExternalReference(std::move(e)) { }
Ifc2x3::IfcExternallyDefinedTextFont::IfcExternallyDefinedTextFont(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference(IfcEntityInstanceData(in_memory_attribute_storage(3))) {  if (v1_Location) {set_attribute_value(0, (*v1_Location)); } if (v2_ItemReference) {set_attribute_value(1, (*v2_ItemReference)); } if (v3_Name) {set_attribute_value(2, (*v3_Name)); }; populate_derived(); }

// Function implementations for IfcExtrudedAreaSolid
::Ifc2x3::IfcDirection* Ifc2x3::IfcExtrudedAreaSolid::ExtrudedDirection() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcDirection>(true); }
void Ifc2x3::IfcExtrudedAreaSolid::setExtrudedDirection(::Ifc2x3::IfcDirection* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
double Ifc2x3::IfcExtrudedAreaSolid::Depth() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcExtrudedAreaSolid::setDepth(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcExtrudedAreaSolid::declaration() const { return *((IfcParse::entity*)IFC2X3_types[327]); }
const IfcParse::entity& Ifc2x3::IfcExtrudedAreaSolid::Class() { return *((IfcParse::entity*)IFC2X3_types[327]); }
Ifc2x3::IfcExtrudedAreaSolid::IfcExtrudedAreaSolid(IfcEntityInstanceData&& e) : IfcSweptAreaSolid(std::move(e)) { }
Ifc2x3::IfcExtrudedAreaSolid::IfcExtrudedAreaSolid(::Ifc2x3::IfcProfileDef* v1_SweptArea, ::Ifc2x3::IfcAxis2Placement3D* v2_Position, ::Ifc2x3::IfcDirection* v3_ExtrudedDirection, double v4_Depth) : IfcSweptAreaSolid(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_SweptArea ? v1_SweptArea->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_Position ? v2_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_ExtrudedDirection ? v3_ExtrudedDirection->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_Depth));; populate_derived(); }

// Function implementations for IfcFace
aggregate_of< ::Ifc2x3::IfcFaceBound >::ptr Ifc2x3::IfcFace::Bounds() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcFaceBound >(); }
void Ifc2x3::IfcFace::setBounds(aggregate_of< ::Ifc2x3::IfcFaceBound >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcFace::declaration() const { return *((IfcParse::entity*)IFC2X3_types[328]); }
const IfcParse::entity& Ifc2x3::IfcFace::Class() { return *((IfcParse::entity*)IFC2X3_types[328]); }
Ifc2x3::IfcFace::IfcFace(IfcEntityInstanceData&& e) : IfcTopologicalRepresentationItem(std::move(e)) { }
Ifc2x3::IfcFace::IfcFace(aggregate_of< ::Ifc2x3::IfcFaceBound >::ptr v1_Bounds) : IfcTopologicalRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Bounds)->generalize());; populate_derived(); }

// Function implementations for IfcFaceBasedSurfaceModel
aggregate_of< ::Ifc2x3::IfcConnectedFaceSet >::ptr Ifc2x3::IfcFaceBasedSurfaceModel::FbsmFaces() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcConnectedFaceSet >(); }
void Ifc2x3::IfcFaceBasedSurfaceModel::setFbsmFaces(aggregate_of< ::Ifc2x3::IfcConnectedFaceSet >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcFaceBasedSurfaceModel::declaration() const { return *((IfcParse::entity*)IFC2X3_types[329]); }
const IfcParse::entity& Ifc2x3::IfcFaceBasedSurfaceModel::Class() { return *((IfcParse::entity*)IFC2X3_types[329]); }
Ifc2x3::IfcFaceBasedSurfaceModel::IfcFaceBasedSurfaceModel(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcFaceBasedSurfaceModel::IfcFaceBasedSurfaceModel(aggregate_of< ::Ifc2x3::IfcConnectedFaceSet >::ptr v1_FbsmFaces) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_FbsmFaces)->generalize());; populate_derived(); }

// Function implementations for IfcFaceBound
::Ifc2x3::IfcLoop* Ifc2x3::IfcFaceBound::Bound() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcLoop>(true); }
void Ifc2x3::IfcFaceBound::setBound(::Ifc2x3::IfcLoop* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
bool Ifc2x3::IfcFaceBound::Orientation() const {  bool v = get_attribute_value(1); return v; }
void Ifc2x3::IfcFaceBound::setOrientation(bool v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcFaceBound::declaration() const { return *((IfcParse::entity*)IFC2X3_types[330]); }
const IfcParse::entity& Ifc2x3::IfcFaceBound::Class() { return *((IfcParse::entity*)IFC2X3_types[330]); }
Ifc2x3::IfcFaceBound::IfcFaceBound(IfcEntityInstanceData&& e) : IfcTopologicalRepresentationItem(std::move(e)) { }
Ifc2x3::IfcFaceBound::IfcFaceBound(::Ifc2x3::IfcLoop* v1_Bound, bool v2_Orientation) : IfcTopologicalRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_Bound ? v1_Bound->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Orientation));; populate_derived(); }

// Function implementations for IfcFaceOuterBound


const IfcParse::entity& Ifc2x3::IfcFaceOuterBound::declaration() const { return *((IfcParse::entity*)IFC2X3_types[331]); }
const IfcParse::entity& Ifc2x3::IfcFaceOuterBound::Class() { return *((IfcParse::entity*)IFC2X3_types[331]); }
Ifc2x3::IfcFaceOuterBound::IfcFaceOuterBound(IfcEntityInstanceData&& e) : IfcFaceBound(std::move(e)) { }
Ifc2x3::IfcFaceOuterBound::IfcFaceOuterBound(::Ifc2x3::IfcLoop* v1_Bound, bool v2_Orientation) : IfcFaceBound(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_Bound ? v1_Bound->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Orientation));; populate_derived(); }

// Function implementations for IfcFaceSurface
::Ifc2x3::IfcSurface* Ifc2x3::IfcFaceSurface::FaceSurface() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcSurface>(true); }
void Ifc2x3::IfcFaceSurface::setFaceSurface(::Ifc2x3::IfcSurface* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
bool Ifc2x3::IfcFaceSurface::SameSense() const {  bool v = get_attribute_value(2); return v; }
void Ifc2x3::IfcFaceSurface::setSameSense(bool v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcFaceSurface::declaration() const { return *((IfcParse::entity*)IFC2X3_types[332]); }
const IfcParse::entity& Ifc2x3::IfcFaceSurface::Class() { return *((IfcParse::entity*)IFC2X3_types[332]); }
Ifc2x3::IfcFaceSurface::IfcFaceSurface(IfcEntityInstanceData&& e) : IfcFace(std::move(e)) { }
Ifc2x3::IfcFaceSurface::IfcFaceSurface(aggregate_of< ::Ifc2x3::IfcFaceBound >::ptr v1_Bounds, ::Ifc2x3::IfcSurface* v2_FaceSurface, bool v3_SameSense) : IfcFace(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, (v1_Bounds)->generalize());set_attribute_value(1, v2_FaceSurface ? v2_FaceSurface->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, (v3_SameSense));; populate_derived(); }

// Function implementations for IfcFacetedBrep


const IfcParse::entity& Ifc2x3::IfcFacetedBrep::declaration() const { return *((IfcParse::entity*)IFC2X3_types[333]); }
const IfcParse::entity& Ifc2x3::IfcFacetedBrep::Class() { return *((IfcParse::entity*)IFC2X3_types[333]); }
Ifc2x3::IfcFacetedBrep::IfcFacetedBrep(IfcEntityInstanceData&& e) : IfcManifoldSolidBrep(std::move(e)) { }
Ifc2x3::IfcFacetedBrep::IfcFacetedBrep(::Ifc2x3::IfcClosedShell* v1_Outer) : IfcManifoldSolidBrep(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, v1_Outer ? v1_Outer->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcFacetedBrepWithVoids
aggregate_of< ::Ifc2x3::IfcClosedShell >::ptr Ifc2x3::IfcFacetedBrepWithVoids::Voids() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcClosedShell >(); }
void Ifc2x3::IfcFacetedBrepWithVoids::setVoids(aggregate_of< ::Ifc2x3::IfcClosedShell >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcFacetedBrepWithVoids::declaration() const { return *((IfcParse::entity*)IFC2X3_types[334]); }
const IfcParse::entity& Ifc2x3::IfcFacetedBrepWithVoids::Class() { return *((IfcParse::entity*)IFC2X3_types[334]); }
Ifc2x3::IfcFacetedBrepWithVoids::IfcFacetedBrepWithVoids(IfcEntityInstanceData&& e) : IfcManifoldSolidBrep(std::move(e)) { }
Ifc2x3::IfcFacetedBrepWithVoids::IfcFacetedBrepWithVoids(::Ifc2x3::IfcClosedShell* v1_Outer, aggregate_of< ::Ifc2x3::IfcClosedShell >::ptr v2_Voids) : IfcManifoldSolidBrep(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_Outer ? v1_Outer->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Voids)->generalize());; populate_derived(); }

// Function implementations for IfcFailureConnectionCondition
boost::optional< double > Ifc2x3::IfcFailureConnectionCondition::TensionFailureX() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcFailureConnectionCondition::setTensionFailureX(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcFailureConnectionCondition::TensionFailureY() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcFailureConnectionCondition::setTensionFailureY(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcFailureConnectionCondition::TensionFailureZ() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcFailureConnectionCondition::setTensionFailureZ(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< double > Ifc2x3::IfcFailureConnectionCondition::CompressionFailureX() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcFailureConnectionCondition::setCompressionFailureX(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< double > Ifc2x3::IfcFailureConnectionCondition::CompressionFailureY() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcFailureConnectionCondition::setCompressionFailureY(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< double > Ifc2x3::IfcFailureConnectionCondition::CompressionFailureZ() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcFailureConnectionCondition::setCompressionFailureZ(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }


const IfcParse::entity& Ifc2x3::IfcFailureConnectionCondition::declaration() const { return *((IfcParse::entity*)IFC2X3_types[335]); }
const IfcParse::entity& Ifc2x3::IfcFailureConnectionCondition::Class() { return *((IfcParse::entity*)IFC2X3_types[335]); }
Ifc2x3::IfcFailureConnectionCondition::IfcFailureConnectionCondition(IfcEntityInstanceData&& e) : IfcStructuralConnectionCondition(std::move(e)) { }
Ifc2x3::IfcFailureConnectionCondition::IfcFailureConnectionCondition(boost::optional< std::string > v1_Name, boost::optional< double > v2_TensionFailureX, boost::optional< double > v3_TensionFailureY, boost::optional< double > v4_TensionFailureZ, boost::optional< double > v5_CompressionFailureX, boost::optional< double > v6_CompressionFailureY, boost::optional< double > v7_CompressionFailureZ) : IfcStructuralConnectionCondition(IfcEntityInstanceData(in_memory_attribute_storage(7))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_TensionFailureX) {set_attribute_value(1, (*v2_TensionFailureX)); } if (v3_TensionFailureY) {set_attribute_value(2, (*v3_TensionFailureY)); } if (v4_TensionFailureZ) {set_attribute_value(3, (*v4_TensionFailureZ)); } if (v5_CompressionFailureX) {set_attribute_value(4, (*v5_CompressionFailureX)); } if (v6_CompressionFailureY) {set_attribute_value(5, (*v6_CompressionFailureY)); } if (v7_CompressionFailureZ) {set_attribute_value(6, (*v7_CompressionFailureZ)); }; populate_derived(); }

// Function implementations for IfcFanType
::Ifc2x3::IfcFanTypeEnum::Value Ifc2x3::IfcFanType::PredefinedType() const {  return ::Ifc2x3::IfcFanTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcFanType::setPredefinedType(::Ifc2x3::IfcFanTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcFanTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcFanType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[336]); }
const IfcParse::entity& Ifc2x3::IfcFanType::Class() { return *((IfcParse::entity*)IFC2X3_types[336]); }
Ifc2x3::IfcFanType::IfcFanType(IfcEntityInstanceData&& e) : IfcFlowMovingDeviceType(std::move(e)) { }
Ifc2x3::IfcFanType::IfcFanType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcFanTypeEnum::Value v10_PredefinedType) : IfcFlowMovingDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcFanTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcFastener


const IfcParse::entity& Ifc2x3::IfcFastener::declaration() const { return *((IfcParse::entity*)IFC2X3_types[338]); }
const IfcParse::entity& Ifc2x3::IfcFastener::Class() { return *((IfcParse::entity*)IFC2X3_types[338]); }
Ifc2x3::IfcFastener::IfcFastener(IfcEntityInstanceData&& e) : IfcElementComponent(std::move(e)) { }
Ifc2x3::IfcFastener::IfcFastener(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElementComponent(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcFastenerType


const IfcParse::entity& Ifc2x3::IfcFastenerType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[339]); }
const IfcParse::entity& Ifc2x3::IfcFastenerType::Class() { return *((IfcParse::entity*)IFC2X3_types[339]); }
Ifc2x3::IfcFastenerType::IfcFastenerType(IfcEntityInstanceData&& e) : IfcElementComponentType(std::move(e)) { }
Ifc2x3::IfcFastenerType::IfcFastenerType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementComponentType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcFeatureElement


const IfcParse::entity& Ifc2x3::IfcFeatureElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[340]); }
const IfcParse::entity& Ifc2x3::IfcFeatureElement::Class() { return *((IfcParse::entity*)IFC2X3_types[340]); }
Ifc2x3::IfcFeatureElement::IfcFeatureElement(IfcEntityInstanceData&& e) : IfcElement(std::move(e)) { }
Ifc2x3::IfcFeatureElement::IfcFeatureElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcFeatureElementAddition

::Ifc2x3::IfcRelProjectsElement::list::ptr Ifc2x3::IfcFeatureElementAddition::ProjectsElements() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[711], 5)->as<IfcRelProjectsElement>(); }

const IfcParse::entity& Ifc2x3::IfcFeatureElementAddition::declaration() const { return *((IfcParse::entity*)IFC2X3_types[341]); }
const IfcParse::entity& Ifc2x3::IfcFeatureElementAddition::Class() { return *((IfcParse::entity*)IFC2X3_types[341]); }
Ifc2x3::IfcFeatureElementAddition::IfcFeatureElementAddition(IfcEntityInstanceData&& e) : IfcFeatureElement(std::move(e)) { }
Ifc2x3::IfcFeatureElementAddition::IfcFeatureElementAddition(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcFeatureElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcFeatureElementSubtraction

::Ifc2x3::IfcRelVoidsElement::list::ptr Ifc2x3::IfcFeatureElementSubtraction::VoidsElements() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[717], 5)->as<IfcRelVoidsElement>(); }

const IfcParse::entity& Ifc2x3::IfcFeatureElementSubtraction::declaration() const { return *((IfcParse::entity*)IFC2X3_types[342]); }
const IfcParse::entity& Ifc2x3::IfcFeatureElementSubtraction::Class() { return *((IfcParse::entity*)IFC2X3_types[342]); }
Ifc2x3::IfcFeatureElementSubtraction::IfcFeatureElementSubtraction(IfcEntityInstanceData&& e) : IfcFeatureElement(std::move(e)) { }
Ifc2x3::IfcFeatureElementSubtraction::IfcFeatureElementSubtraction(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcFeatureElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcFillAreaStyle
aggregate_of< ::Ifc2x3::IfcFillStyleSelect >::ptr Ifc2x3::IfcFillAreaStyle::FillStyles() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcFillStyleSelect >(); }
void Ifc2x3::IfcFillAreaStyle::setFillStyles(aggregate_of< ::Ifc2x3::IfcFillStyleSelect >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcFillAreaStyle::declaration() const { return *((IfcParse::entity*)IFC2X3_types[343]); }
const IfcParse::entity& Ifc2x3::IfcFillAreaStyle::Class() { return *((IfcParse::entity*)IFC2X3_types[343]); }
Ifc2x3::IfcFillAreaStyle::IfcFillAreaStyle(IfcEntityInstanceData&& e) : IfcPresentationStyle(std::move(e)) { }
Ifc2x3::IfcFillAreaStyle::IfcFillAreaStyle(boost::optional< std::string > v1_Name, aggregate_of< ::Ifc2x3::IfcFillStyleSelect >::ptr v2_FillStyles) : IfcPresentationStyle(IfcEntityInstanceData(in_memory_attribute_storage(2))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (v2_FillStyles)->generalize());; populate_derived(); }

// Function implementations for IfcFillAreaStyleHatching
::Ifc2x3::IfcCurveStyle* Ifc2x3::IfcFillAreaStyleHatching::HatchLineAppearance() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcCurveStyle>(true); }
void Ifc2x3::IfcFillAreaStyleHatching::setHatchLineAppearance(::Ifc2x3::IfcCurveStyle* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcHatchLineDistanceSelect* Ifc2x3::IfcFillAreaStyleHatching::StartOfNextHatchLine() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcHatchLineDistanceSelect>(true); }
void Ifc2x3::IfcFillAreaStyleHatching::setStartOfNextHatchLine(::Ifc2x3::IfcHatchLineDistanceSelect* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcCartesianPoint* Ifc2x3::IfcFillAreaStyleHatching::PointOfReferenceHatchLine() const { if(get_attribute_value(2).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcCartesianPoint>(true); }
void Ifc2x3::IfcFillAreaStyleHatching::setPointOfReferenceHatchLine(::Ifc2x3::IfcCartesianPoint* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcCartesianPoint* Ifc2x3::IfcFillAreaStyleHatching::PatternStart() const { if(get_attribute_value(3).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcCartesianPoint>(true); }
void Ifc2x3::IfcFillAreaStyleHatching::setPatternStart(::Ifc2x3::IfcCartesianPoint* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }
double Ifc2x3::IfcFillAreaStyleHatching::HatchLineAngle() const {  double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcFillAreaStyleHatching::setHatchLineAngle(double v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcFillAreaStyleHatching::declaration() const { return *((IfcParse::entity*)IFC2X3_types[344]); }
const IfcParse::entity& Ifc2x3::IfcFillAreaStyleHatching::Class() { return *((IfcParse::entity*)IFC2X3_types[344]); }
Ifc2x3::IfcFillAreaStyleHatching::IfcFillAreaStyleHatching(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcFillAreaStyleHatching::IfcFillAreaStyleHatching(::Ifc2x3::IfcCurveStyle* v1_HatchLineAppearance, ::Ifc2x3::IfcHatchLineDistanceSelect* v2_StartOfNextHatchLine, ::Ifc2x3::IfcCartesianPoint* v3_PointOfReferenceHatchLine, ::Ifc2x3::IfcCartesianPoint* v4_PatternStart, double v5_HatchLineAngle) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, v1_HatchLineAppearance ? v1_HatchLineAppearance->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_StartOfNextHatchLine ? v2_StartOfNextHatchLine->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_PointOfReferenceHatchLine ? v3_PointOfReferenceHatchLine->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_PatternStart ? v4_PatternStart->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(4, (v5_HatchLineAngle));; populate_derived(); }

// Function implementations for IfcFillAreaStyleTileSymbolWithStyle
::Ifc2x3::IfcAnnotationSymbolOccurrence* Ifc2x3::IfcFillAreaStyleTileSymbolWithStyle::Symbol() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcAnnotationSymbolOccurrence>(true); }
void Ifc2x3::IfcFillAreaStyleTileSymbolWithStyle::setSymbol(::Ifc2x3::IfcAnnotationSymbolOccurrence* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcFillAreaStyleTileSymbolWithStyle::declaration() const { return *((IfcParse::entity*)IFC2X3_types[347]); }
const IfcParse::entity& Ifc2x3::IfcFillAreaStyleTileSymbolWithStyle::Class() { return *((IfcParse::entity*)IFC2X3_types[347]); }
Ifc2x3::IfcFillAreaStyleTileSymbolWithStyle::IfcFillAreaStyleTileSymbolWithStyle(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcFillAreaStyleTileSymbolWithStyle::IfcFillAreaStyleTileSymbolWithStyle(::Ifc2x3::IfcAnnotationSymbolOccurrence* v1_Symbol) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, v1_Symbol ? v1_Symbol->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcFillAreaStyleTiles
::Ifc2x3::IfcOneDirectionRepeatFactor* Ifc2x3::IfcFillAreaStyleTiles::TilingPattern() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcOneDirectionRepeatFactor>(true); }
void Ifc2x3::IfcFillAreaStyleTiles::setTilingPattern(::Ifc2x3::IfcOneDirectionRepeatFactor* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcFillAreaStyleTileShapeSelect >::ptr Ifc2x3::IfcFillAreaStyleTiles::Tiles() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcFillAreaStyleTileShapeSelect >(); }
void Ifc2x3::IfcFillAreaStyleTiles::setTiles(aggregate_of< ::Ifc2x3::IfcFillAreaStyleTileShapeSelect >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }
double Ifc2x3::IfcFillAreaStyleTiles::TilingScale() const {  double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcFillAreaStyleTiles::setTilingScale(double v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcFillAreaStyleTiles::declaration() const { return *((IfcParse::entity*)IFC2X3_types[345]); }
const IfcParse::entity& Ifc2x3::IfcFillAreaStyleTiles::Class() { return *((IfcParse::entity*)IFC2X3_types[345]); }
Ifc2x3::IfcFillAreaStyleTiles::IfcFillAreaStyleTiles(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcFillAreaStyleTiles::IfcFillAreaStyleTiles(::Ifc2x3::IfcOneDirectionRepeatFactor* v1_TilingPattern, aggregate_of< ::Ifc2x3::IfcFillAreaStyleTileShapeSelect >::ptr v2_Tiles, double v3_TilingScale) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_TilingPattern ? v1_TilingPattern->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Tiles)->generalize());set_attribute_value(2, (v3_TilingScale));; populate_derived(); }

// Function implementations for IfcFilterType
::Ifc2x3::IfcFilterTypeEnum::Value Ifc2x3::IfcFilterType::PredefinedType() const {  return ::Ifc2x3::IfcFilterTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcFilterType::setPredefinedType(::Ifc2x3::IfcFilterTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcFilterTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcFilterType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[349]); }
const IfcParse::entity& Ifc2x3::IfcFilterType::Class() { return *((IfcParse::entity*)IFC2X3_types[349]); }
Ifc2x3::IfcFilterType::IfcFilterType(IfcEntityInstanceData&& e) : IfcFlowTreatmentDeviceType(std::move(e)) { }
Ifc2x3::IfcFilterType::IfcFilterType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcFilterTypeEnum::Value v10_PredefinedType) : IfcFlowTreatmentDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcFilterTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcFireSuppressionTerminalType
::Ifc2x3::IfcFireSuppressionTerminalTypeEnum::Value Ifc2x3::IfcFireSuppressionTerminalType::PredefinedType() const {  return ::Ifc2x3::IfcFireSuppressionTerminalTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcFireSuppressionTerminalType::setPredefinedType(::Ifc2x3::IfcFireSuppressionTerminalTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcFireSuppressionTerminalTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcFireSuppressionTerminalType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[351]); }
const IfcParse::entity& Ifc2x3::IfcFireSuppressionTerminalType::Class() { return *((IfcParse::entity*)IFC2X3_types[351]); }
Ifc2x3::IfcFireSuppressionTerminalType::IfcFireSuppressionTerminalType(IfcEntityInstanceData&& e) : IfcFlowTerminalType(std::move(e)) { }
Ifc2x3::IfcFireSuppressionTerminalType::IfcFireSuppressionTerminalType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcFireSuppressionTerminalTypeEnum::Value v10_PredefinedType) : IfcFlowTerminalType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcFireSuppressionTerminalTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcFlowController


const IfcParse::entity& Ifc2x3::IfcFlowController::declaration() const { return *((IfcParse::entity*)IFC2X3_types[353]); }
const IfcParse::entity& Ifc2x3::IfcFlowController::Class() { return *((IfcParse::entity*)IFC2X3_types[353]); }
Ifc2x3::IfcFlowController::IfcFlowController(IfcEntityInstanceData&& e) : IfcDistributionFlowElement(std::move(e)) { }
Ifc2x3::IfcFlowController::IfcFlowController(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcFlowControllerType


const IfcParse::entity& Ifc2x3::IfcFlowControllerType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[354]); }
const IfcParse::entity& Ifc2x3::IfcFlowControllerType::Class() { return *((IfcParse::entity*)IFC2X3_types[354]); }
Ifc2x3::IfcFlowControllerType::IfcFlowControllerType(IfcEntityInstanceData&& e) : IfcDistributionFlowElementType(std::move(e)) { }
Ifc2x3::IfcFlowControllerType::IfcFlowControllerType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcFlowFitting


const IfcParse::entity& Ifc2x3::IfcFlowFitting::declaration() const { return *((IfcParse::entity*)IFC2X3_types[356]); }
const IfcParse::entity& Ifc2x3::IfcFlowFitting::Class() { return *((IfcParse::entity*)IFC2X3_types[356]); }
Ifc2x3::IfcFlowFitting::IfcFlowFitting(IfcEntityInstanceData&& e) : IfcDistributionFlowElement(std::move(e)) { }
Ifc2x3::IfcFlowFitting::IfcFlowFitting(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcFlowFittingType


const IfcParse::entity& Ifc2x3::IfcFlowFittingType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[357]); }
const IfcParse::entity& Ifc2x3::IfcFlowFittingType::Class() { return *((IfcParse::entity*)IFC2X3_types[357]); }
Ifc2x3::IfcFlowFittingType::IfcFlowFittingType(IfcEntityInstanceData&& e) : IfcDistributionFlowElementType(std::move(e)) { }
Ifc2x3::IfcFlowFittingType::IfcFlowFittingType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcFlowInstrumentType
::Ifc2x3::IfcFlowInstrumentTypeEnum::Value Ifc2x3::IfcFlowInstrumentType::PredefinedType() const {  return ::Ifc2x3::IfcFlowInstrumentTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcFlowInstrumentType::setPredefinedType(::Ifc2x3::IfcFlowInstrumentTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcFlowInstrumentTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcFlowInstrumentType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[358]); }
const IfcParse::entity& Ifc2x3::IfcFlowInstrumentType::Class() { return *((IfcParse::entity*)IFC2X3_types[358]); }
Ifc2x3::IfcFlowInstrumentType::IfcFlowInstrumentType(IfcEntityInstanceData&& e) : IfcDistributionControlElementType(std::move(e)) { }
Ifc2x3::IfcFlowInstrumentType::IfcFlowInstrumentType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcFlowInstrumentTypeEnum::Value v10_PredefinedType) : IfcDistributionControlElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcFlowInstrumentTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcFlowMeterType
::Ifc2x3::IfcFlowMeterTypeEnum::Value Ifc2x3::IfcFlowMeterType::PredefinedType() const {  return ::Ifc2x3::IfcFlowMeterTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcFlowMeterType::setPredefinedType(::Ifc2x3::IfcFlowMeterTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcFlowMeterTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcFlowMeterType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[360]); }
const IfcParse::entity& Ifc2x3::IfcFlowMeterType::Class() { return *((IfcParse::entity*)IFC2X3_types[360]); }
Ifc2x3::IfcFlowMeterType::IfcFlowMeterType(IfcEntityInstanceData&& e) : IfcFlowControllerType(std::move(e)) { }
Ifc2x3::IfcFlowMeterType::IfcFlowMeterType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcFlowMeterTypeEnum::Value v10_PredefinedType) : IfcFlowControllerType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcFlowMeterTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcFlowMovingDevice


const IfcParse::entity& Ifc2x3::IfcFlowMovingDevice::declaration() const { return *((IfcParse::entity*)IFC2X3_types[362]); }
const IfcParse::entity& Ifc2x3::IfcFlowMovingDevice::Class() { return *((IfcParse::entity*)IFC2X3_types[362]); }
Ifc2x3::IfcFlowMovingDevice::IfcFlowMovingDevice(IfcEntityInstanceData&& e) : IfcDistributionFlowElement(std::move(e)) { }
Ifc2x3::IfcFlowMovingDevice::IfcFlowMovingDevice(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcFlowMovingDeviceType


const IfcParse::entity& Ifc2x3::IfcFlowMovingDeviceType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[363]); }
const IfcParse::entity& Ifc2x3::IfcFlowMovingDeviceType::Class() { return *((IfcParse::entity*)IFC2X3_types[363]); }
Ifc2x3::IfcFlowMovingDeviceType::IfcFlowMovingDeviceType(IfcEntityInstanceData&& e) : IfcDistributionFlowElementType(std::move(e)) { }
Ifc2x3::IfcFlowMovingDeviceType::IfcFlowMovingDeviceType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcFlowSegment


const IfcParse::entity& Ifc2x3::IfcFlowSegment::declaration() const { return *((IfcParse::entity*)IFC2X3_types[364]); }
const IfcParse::entity& Ifc2x3::IfcFlowSegment::Class() { return *((IfcParse::entity*)IFC2X3_types[364]); }
Ifc2x3::IfcFlowSegment::IfcFlowSegment(IfcEntityInstanceData&& e) : IfcDistributionFlowElement(std::move(e)) { }
Ifc2x3::IfcFlowSegment::IfcFlowSegment(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcFlowSegmentType


const IfcParse::entity& Ifc2x3::IfcFlowSegmentType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[365]); }
const IfcParse::entity& Ifc2x3::IfcFlowSegmentType::Class() { return *((IfcParse::entity*)IFC2X3_types[365]); }
Ifc2x3::IfcFlowSegmentType::IfcFlowSegmentType(IfcEntityInstanceData&& e) : IfcDistributionFlowElementType(std::move(e)) { }
Ifc2x3::IfcFlowSegmentType::IfcFlowSegmentType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcFlowStorageDevice


const IfcParse::entity& Ifc2x3::IfcFlowStorageDevice::declaration() const { return *((IfcParse::entity*)IFC2X3_types[366]); }
const IfcParse::entity& Ifc2x3::IfcFlowStorageDevice::Class() { return *((IfcParse::entity*)IFC2X3_types[366]); }
Ifc2x3::IfcFlowStorageDevice::IfcFlowStorageDevice(IfcEntityInstanceData&& e) : IfcDistributionFlowElement(std::move(e)) { }
Ifc2x3::IfcFlowStorageDevice::IfcFlowStorageDevice(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcFlowStorageDeviceType


const IfcParse::entity& Ifc2x3::IfcFlowStorageDeviceType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[367]); }
const IfcParse::entity& Ifc2x3::IfcFlowStorageDeviceType::Class() { return *((IfcParse::entity*)IFC2X3_types[367]); }
Ifc2x3::IfcFlowStorageDeviceType::IfcFlowStorageDeviceType(IfcEntityInstanceData&& e) : IfcDistributionFlowElementType(std::move(e)) { }
Ifc2x3::IfcFlowStorageDeviceType::IfcFlowStorageDeviceType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcFlowTerminal


const IfcParse::entity& Ifc2x3::IfcFlowTerminal::declaration() const { return *((IfcParse::entity*)IFC2X3_types[368]); }
const IfcParse::entity& Ifc2x3::IfcFlowTerminal::Class() { return *((IfcParse::entity*)IFC2X3_types[368]); }
Ifc2x3::IfcFlowTerminal::IfcFlowTerminal(IfcEntityInstanceData&& e) : IfcDistributionFlowElement(std::move(e)) { }
Ifc2x3::IfcFlowTerminal::IfcFlowTerminal(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcFlowTerminalType


const IfcParse::entity& Ifc2x3::IfcFlowTerminalType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[369]); }
const IfcParse::entity& Ifc2x3::IfcFlowTerminalType::Class() { return *((IfcParse::entity*)IFC2X3_types[369]); }
Ifc2x3::IfcFlowTerminalType::IfcFlowTerminalType(IfcEntityInstanceData&& e) : IfcDistributionFlowElementType(std::move(e)) { }
Ifc2x3::IfcFlowTerminalType::IfcFlowTerminalType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcFlowTreatmentDevice


const IfcParse::entity& Ifc2x3::IfcFlowTreatmentDevice::declaration() const { return *((IfcParse::entity*)IFC2X3_types[370]); }
const IfcParse::entity& Ifc2x3::IfcFlowTreatmentDevice::Class() { return *((IfcParse::entity*)IFC2X3_types[370]); }
Ifc2x3::IfcFlowTreatmentDevice::IfcFlowTreatmentDevice(IfcEntityInstanceData&& e) : IfcDistributionFlowElement(std::move(e)) { }
Ifc2x3::IfcFlowTreatmentDevice::IfcFlowTreatmentDevice(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcDistributionFlowElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcFlowTreatmentDeviceType


const IfcParse::entity& Ifc2x3::IfcFlowTreatmentDeviceType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[371]); }
const IfcParse::entity& Ifc2x3::IfcFlowTreatmentDeviceType::Class() { return *((IfcParse::entity*)IFC2X3_types[371]); }
Ifc2x3::IfcFlowTreatmentDeviceType::IfcFlowTreatmentDeviceType(IfcEntityInstanceData&& e) : IfcDistributionFlowElementType(std::move(e)) { }
Ifc2x3::IfcFlowTreatmentDeviceType::IfcFlowTreatmentDeviceType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcDistributionFlowElementType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcFluidFlowProperties
::Ifc2x3::IfcPropertySourceEnum::Value Ifc2x3::IfcFluidFlowProperties::PropertySource() const {  return ::Ifc2x3::IfcPropertySourceEnum::FromString(get_attribute_value(4)); }
void Ifc2x3::IfcFluidFlowProperties::setPropertySource(::Ifc2x3::IfcPropertySourceEnum::Value v) { set_attribute_value(4, EnumerationReference(&::Ifc2x3::IfcPropertySourceEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcTimeSeries* Ifc2x3::IfcFluidFlowProperties::FlowConditionTimeSeries() const { if(get_attribute_value(5).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcTimeSeries>(true); }
void Ifc2x3::IfcFluidFlowProperties::setFlowConditionTimeSeries(::Ifc2x3::IfcTimeSeries* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcTimeSeries* Ifc2x3::IfcFluidFlowProperties::VelocityTimeSeries() const { if(get_attribute_value(6).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcTimeSeries>(true); }
void Ifc2x3::IfcFluidFlowProperties::setVelocityTimeSeries(::Ifc2x3::IfcTimeSeries* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
::Ifc2x3::IfcTimeSeries* Ifc2x3::IfcFluidFlowProperties::FlowrateTimeSeries() const { if(get_attribute_value(7).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(7)))->as<::Ifc2x3::IfcTimeSeries>(true); }
void Ifc2x3::IfcFluidFlowProperties::setFlowrateTimeSeries(::Ifc2x3::IfcTimeSeries* v) { set_attribute_value(7, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(7); }
::Ifc2x3::IfcMaterial* Ifc2x3::IfcFluidFlowProperties::Fluid() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(8)))->as<::Ifc2x3::IfcMaterial>(true); }
void Ifc2x3::IfcFluidFlowProperties::setFluid(::Ifc2x3::IfcMaterial* v) { set_attribute_value(8, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(8); }
::Ifc2x3::IfcTimeSeries* Ifc2x3::IfcFluidFlowProperties::PressureTimeSeries() const { if(get_attribute_value(9).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(9)))->as<::Ifc2x3::IfcTimeSeries>(true); }
void Ifc2x3::IfcFluidFlowProperties::setPressureTimeSeries(::Ifc2x3::IfcTimeSeries* v) { set_attribute_value(9, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(9); }
boost::optional< std::string > Ifc2x3::IfcFluidFlowProperties::UserDefinedPropertySource() const { if(get_attribute_value(10).isNull()) { return boost::none; } std::string v = get_attribute_value(10); return v; }
void Ifc2x3::IfcFluidFlowProperties::setUserDefinedPropertySource(boost::optional< std::string > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
boost::optional< double > Ifc2x3::IfcFluidFlowProperties::TemperatureSingleValue() const { if(get_attribute_value(11).isNull()) { return boost::none; } double v = get_attribute_value(11); return v; }
void Ifc2x3::IfcFluidFlowProperties::setTemperatureSingleValue(boost::optional< double > v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
boost::optional< double > Ifc2x3::IfcFluidFlowProperties::WetBulbTemperatureSingleValue() const { if(get_attribute_value(12).isNull()) { return boost::none; } double v = get_attribute_value(12); return v; }
void Ifc2x3::IfcFluidFlowProperties::setWetBulbTemperatureSingleValue(boost::optional< double > v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
::Ifc2x3::IfcTimeSeries* Ifc2x3::IfcFluidFlowProperties::WetBulbTemperatureTimeSeries() const { if(get_attribute_value(13).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(13)))->as<::Ifc2x3::IfcTimeSeries>(true); }
void Ifc2x3::IfcFluidFlowProperties::setWetBulbTemperatureTimeSeries(::Ifc2x3::IfcTimeSeries* v) { set_attribute_value(13, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(13); }
::Ifc2x3::IfcTimeSeries* Ifc2x3::IfcFluidFlowProperties::TemperatureTimeSeries() const { if(get_attribute_value(14).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(14)))->as<::Ifc2x3::IfcTimeSeries>(true); }
void Ifc2x3::IfcFluidFlowProperties::setTemperatureTimeSeries(::Ifc2x3::IfcTimeSeries* v) { set_attribute_value(14, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(14); }
::Ifc2x3::IfcDerivedMeasureValue* Ifc2x3::IfcFluidFlowProperties::FlowrateSingleValue() const { if(get_attribute_value(15).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(15)))->as<::Ifc2x3::IfcDerivedMeasureValue>(true); }
void Ifc2x3::IfcFluidFlowProperties::setFlowrateSingleValue(::Ifc2x3::IfcDerivedMeasureValue* v) { set_attribute_value(15, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(15); }
boost::optional< double > Ifc2x3::IfcFluidFlowProperties::FlowConditionSingleValue() const { if(get_attribute_value(16).isNull()) { return boost::none; } double v = get_attribute_value(16); return v; }
void Ifc2x3::IfcFluidFlowProperties::setFlowConditionSingleValue(boost::optional< double > v) { if (v) {set_attribute_value(16, *v);} else {unset_attribute_value(16);} }
boost::optional< double > Ifc2x3::IfcFluidFlowProperties::VelocitySingleValue() const { if(get_attribute_value(17).isNull()) { return boost::none; } double v = get_attribute_value(17); return v; }
void Ifc2x3::IfcFluidFlowProperties::setVelocitySingleValue(boost::optional< double > v) { if (v) {set_attribute_value(17, *v);} else {unset_attribute_value(17);} }
boost::optional< double > Ifc2x3::IfcFluidFlowProperties::PressureSingleValue() const { if(get_attribute_value(18).isNull()) { return boost::none; } double v = get_attribute_value(18); return v; }
void Ifc2x3::IfcFluidFlowProperties::setPressureSingleValue(boost::optional< double > v) { if (v) {set_attribute_value(18, *v);} else {unset_attribute_value(18);} }


const IfcParse::entity& Ifc2x3::IfcFluidFlowProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[372]); }
const IfcParse::entity& Ifc2x3::IfcFluidFlowProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[372]); }
Ifc2x3::IfcFluidFlowProperties::IfcFluidFlowProperties(IfcEntityInstanceData&& e) : IfcPropertySetDefinition(std::move(e)) { }
Ifc2x3::IfcFluidFlowProperties::IfcFluidFlowProperties(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcPropertySourceEnum::Value v5_PropertySource, ::Ifc2x3::IfcTimeSeries* v6_FlowConditionTimeSeries, ::Ifc2x3::IfcTimeSeries* v7_VelocityTimeSeries, ::Ifc2x3::IfcTimeSeries* v8_FlowrateTimeSeries, ::Ifc2x3::IfcMaterial* v9_Fluid, ::Ifc2x3::IfcTimeSeries* v10_PressureTimeSeries, boost::optional< std::string > v11_UserDefinedPropertySource, boost::optional< double > v12_TemperatureSingleValue, boost::optional< double > v13_WetBulbTemperatureSingleValue, ::Ifc2x3::IfcTimeSeries* v14_WetBulbTemperatureTimeSeries, ::Ifc2x3::IfcTimeSeries* v15_TemperatureTimeSeries, ::Ifc2x3::IfcDerivedMeasureValue* v16_FlowrateSingleValue, boost::optional< double > v17_FlowConditionSingleValue, boost::optional< double > v18_VelocitySingleValue, boost::optional< double > v19_PressureSingleValue) : IfcPropertySetDefinition(IfcEntityInstanceData(in_memory_attribute_storage(19))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (EnumerationReference(&::Ifc2x3::IfcPropertySourceEnum::Class(),(size_t)v5_PropertySource)));set_attribute_value(5, v6_FlowConditionTimeSeries ? v6_FlowConditionTimeSeries->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_VelocityTimeSeries ? v7_VelocityTimeSeries->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_FlowrateTimeSeries ? v8_FlowrateTimeSeries->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(8, v9_Fluid ? v9_Fluid->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(9, v10_PressureTimeSeries ? v10_PressureTimeSeries->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v11_UserDefinedPropertySource) {set_attribute_value(10, (*v11_UserDefinedPropertySource)); } if (v12_TemperatureSingleValue) {set_attribute_value(11, (*v12_TemperatureSingleValue)); } if (v13_WetBulbTemperatureSingleValue) {set_attribute_value(12, (*v13_WetBulbTemperatureSingleValue)); }set_attribute_value(13, v14_WetBulbTemperatureTimeSeries ? v14_WetBulbTemperatureTimeSeries->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(14, v15_TemperatureTimeSeries ? v15_TemperatureTimeSeries->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(15, v16_FlowrateSingleValue ? v16_FlowrateSingleValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v17_FlowConditionSingleValue) {set_attribute_value(16, (*v17_FlowConditionSingleValue)); } if (v18_VelocitySingleValue) {set_attribute_value(17, (*v18_VelocitySingleValue)); } if (v19_PressureSingleValue) {set_attribute_value(18, (*v19_PressureSingleValue)); }; populate_derived(); }

// Function implementations for IfcFooting
::Ifc2x3::IfcFootingTypeEnum::Value Ifc2x3::IfcFooting::PredefinedType() const {  return ::Ifc2x3::IfcFootingTypeEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcFooting::setPredefinedType(::Ifc2x3::IfcFootingTypeEnum::Value v) { set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcFootingTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }


const IfcParse::entity& Ifc2x3::IfcFooting::declaration() const { return *((IfcParse::entity*)IFC2X3_types[376]); }
const IfcParse::entity& Ifc2x3::IfcFooting::Class() { return *((IfcParse::entity*)IFC2X3_types[376]); }
Ifc2x3::IfcFooting::IfcFooting(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcFooting::IfcFooting(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, ::Ifc2x3::IfcFootingTypeEnum::Value v9_PredefinedType) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcFootingTypeEnum::Class(),(size_t)v9_PredefinedType)));; populate_derived(); }

// Function implementations for IfcFuelProperties
boost::optional< double > Ifc2x3::IfcFuelProperties::CombustionTemperature() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcFuelProperties::setCombustionTemperature(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcFuelProperties::CarbonContent() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcFuelProperties::setCarbonContent(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcFuelProperties::LowerHeatingValue() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcFuelProperties::setLowerHeatingValue(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< double > Ifc2x3::IfcFuelProperties::HigherHeatingValue() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcFuelProperties::setHigherHeatingValue(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }


const IfcParse::entity& Ifc2x3::IfcFuelProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[380]); }
const IfcParse::entity& Ifc2x3::IfcFuelProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[380]); }
Ifc2x3::IfcFuelProperties::IfcFuelProperties(IfcEntityInstanceData&& e) : IfcMaterialProperties(std::move(e)) { }
Ifc2x3::IfcFuelProperties::IfcFuelProperties(::Ifc2x3::IfcMaterial* v1_Material, boost::optional< double > v2_CombustionTemperature, boost::optional< double > v3_CarbonContent, boost::optional< double > v4_LowerHeatingValue, boost::optional< double > v5_HigherHeatingValue) : IfcMaterialProperties(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, v1_Material ? v1_Material->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_CombustionTemperature) {set_attribute_value(1, (*v2_CombustionTemperature)); } if (v3_CarbonContent) {set_attribute_value(2, (*v3_CarbonContent)); } if (v4_LowerHeatingValue) {set_attribute_value(3, (*v4_LowerHeatingValue)); } if (v5_HigherHeatingValue) {set_attribute_value(4, (*v5_HigherHeatingValue)); }; populate_derived(); }

// Function implementations for IfcFurnishingElement


const IfcParse::entity& Ifc2x3::IfcFurnishingElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[381]); }
const IfcParse::entity& Ifc2x3::IfcFurnishingElement::Class() { return *((IfcParse::entity*)IFC2X3_types[381]); }
Ifc2x3::IfcFurnishingElement::IfcFurnishingElement(IfcEntityInstanceData&& e) : IfcElement(std::move(e)) { }
Ifc2x3::IfcFurnishingElement::IfcFurnishingElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcFurnishingElementType


const IfcParse::entity& Ifc2x3::IfcFurnishingElementType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[382]); }
const IfcParse::entity& Ifc2x3::IfcFurnishingElementType::Class() { return *((IfcParse::entity*)IFC2X3_types[382]); }
Ifc2x3::IfcFurnishingElementType::IfcFurnishingElementType(IfcEntityInstanceData&& e) : IfcElementType(std::move(e)) { }
Ifc2x3::IfcFurnishingElementType::IfcFurnishingElementType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcFurnitureStandard


const IfcParse::entity& Ifc2x3::IfcFurnitureStandard::declaration() const { return *((IfcParse::entity*)IFC2X3_types[383]); }
const IfcParse::entity& Ifc2x3::IfcFurnitureStandard::Class() { return *((IfcParse::entity*)IFC2X3_types[383]); }
Ifc2x3::IfcFurnitureStandard::IfcFurnitureStandard(IfcEntityInstanceData&& e) : IfcControl(std::move(e)) { }
Ifc2x3::IfcFurnitureStandard::IfcFurnitureStandard(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcControl(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }; populate_derived(); }

// Function implementations for IfcFurnitureType
::Ifc2x3::IfcAssemblyPlaceEnum::Value Ifc2x3::IfcFurnitureType::AssemblyPlace() const {  return ::Ifc2x3::IfcAssemblyPlaceEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcFurnitureType::setAssemblyPlace(::Ifc2x3::IfcAssemblyPlaceEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcAssemblyPlaceEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcFurnitureType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[384]); }
const IfcParse::entity& Ifc2x3::IfcFurnitureType::Class() { return *((IfcParse::entity*)IFC2X3_types[384]); }
Ifc2x3::IfcFurnitureType::IfcFurnitureType(IfcEntityInstanceData&& e) : IfcFurnishingElementType(std::move(e)) { }
Ifc2x3::IfcFurnitureType::IfcFurnitureType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcAssemblyPlaceEnum::Value v10_AssemblyPlace) : IfcFurnishingElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcAssemblyPlaceEnum::Class(),(size_t)v10_AssemblyPlace)));; populate_derived(); }

// Function implementations for IfcGasTerminalType
::Ifc2x3::IfcGasTerminalTypeEnum::Value Ifc2x3::IfcGasTerminalType::PredefinedType() const {  return ::Ifc2x3::IfcGasTerminalTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcGasTerminalType::setPredefinedType(::Ifc2x3::IfcGasTerminalTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcGasTerminalTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcGasTerminalType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[385]); }
const IfcParse::entity& Ifc2x3::IfcGasTerminalType::Class() { return *((IfcParse::entity*)IFC2X3_types[385]); }
Ifc2x3::IfcGasTerminalType::IfcGasTerminalType(IfcEntityInstanceData&& e) : IfcFlowTerminalType(std::move(e)) { }
Ifc2x3::IfcGasTerminalType::IfcGasTerminalType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcGasTerminalTypeEnum::Value v10_PredefinedType) : IfcFlowTerminalType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcGasTerminalTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcGeneralMaterialProperties
boost::optional< double > Ifc2x3::IfcGeneralMaterialProperties::MolecularWeight() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcGeneralMaterialProperties::setMolecularWeight(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcGeneralMaterialProperties::Porosity() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcGeneralMaterialProperties::setPorosity(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcGeneralMaterialProperties::MassDensity() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcGeneralMaterialProperties::setMassDensity(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }


const IfcParse::entity& Ifc2x3::IfcGeneralMaterialProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[387]); }
const IfcParse::entity& Ifc2x3::IfcGeneralMaterialProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[387]); }
Ifc2x3::IfcGeneralMaterialProperties::IfcGeneralMaterialProperties(IfcEntityInstanceData&& e) : IfcMaterialProperties(std::move(e)) { }
Ifc2x3::IfcGeneralMaterialProperties::IfcGeneralMaterialProperties(::Ifc2x3::IfcMaterial* v1_Material, boost::optional< double > v2_MolecularWeight, boost::optional< double > v3_Porosity, boost::optional< double > v4_MassDensity) : IfcMaterialProperties(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_Material ? v1_Material->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_MolecularWeight) {set_attribute_value(1, (*v2_MolecularWeight)); } if (v3_Porosity) {set_attribute_value(2, (*v3_Porosity)); } if (v4_MassDensity) {set_attribute_value(3, (*v4_MassDensity)); }; populate_derived(); }

// Function implementations for IfcGeneralProfileProperties
boost::optional< double > Ifc2x3::IfcGeneralProfileProperties::PhysicalWeight() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcGeneralProfileProperties::setPhysicalWeight(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcGeneralProfileProperties::Perimeter() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcGeneralProfileProperties::setPerimeter(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< double > Ifc2x3::IfcGeneralProfileProperties::MinimumPlateThickness() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcGeneralProfileProperties::setMinimumPlateThickness(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< double > Ifc2x3::IfcGeneralProfileProperties::MaximumPlateThickness() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcGeneralProfileProperties::setMaximumPlateThickness(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< double > Ifc2x3::IfcGeneralProfileProperties::CrossSectionArea() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcGeneralProfileProperties::setCrossSectionArea(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }


const IfcParse::entity& Ifc2x3::IfcGeneralProfileProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[388]); }
const IfcParse::entity& Ifc2x3::IfcGeneralProfileProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[388]); }
Ifc2x3::IfcGeneralProfileProperties::IfcGeneralProfileProperties(IfcEntityInstanceData&& e) : IfcProfileProperties(std::move(e)) { }
Ifc2x3::IfcGeneralProfileProperties::IfcGeneralProfileProperties(boost::optional< std::string > v1_ProfileName, ::Ifc2x3::IfcProfileDef* v2_ProfileDefinition, boost::optional< double > v3_PhysicalWeight, boost::optional< double > v4_Perimeter, boost::optional< double > v5_MinimumPlateThickness, boost::optional< double > v6_MaximumPlateThickness, boost::optional< double > v7_CrossSectionArea) : IfcProfileProperties(IfcEntityInstanceData(in_memory_attribute_storage(7))) {  if (v1_ProfileName) {set_attribute_value(0, (*v1_ProfileName)); }set_attribute_value(1, v2_ProfileDefinition ? v2_ProfileDefinition->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_PhysicalWeight) {set_attribute_value(2, (*v3_PhysicalWeight)); } if (v4_Perimeter) {set_attribute_value(3, (*v4_Perimeter)); } if (v5_MinimumPlateThickness) {set_attribute_value(4, (*v5_MinimumPlateThickness)); } if (v6_MaximumPlateThickness) {set_attribute_value(5, (*v6_MaximumPlateThickness)); } if (v7_CrossSectionArea) {set_attribute_value(6, (*v7_CrossSectionArea)); }; populate_derived(); }

// Function implementations for IfcGeometricCurveSet


const IfcParse::entity& Ifc2x3::IfcGeometricCurveSet::declaration() const { return *((IfcParse::entity*)IFC2X3_types[389]); }
const IfcParse::entity& Ifc2x3::IfcGeometricCurveSet::Class() { return *((IfcParse::entity*)IFC2X3_types[389]); }
Ifc2x3::IfcGeometricCurveSet::IfcGeometricCurveSet(IfcEntityInstanceData&& e) : IfcGeometricSet(std::move(e)) { }
Ifc2x3::IfcGeometricCurveSet::IfcGeometricCurveSet(aggregate_of< ::Ifc2x3::IfcGeometricSetSelect >::ptr v1_Elements) : IfcGeometricSet(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Elements)->generalize());; populate_derived(); }

// Function implementations for IfcGeometricRepresentationContext
int Ifc2x3::IfcGeometricRepresentationContext::CoordinateSpaceDimension() const {  int v = get_attribute_value(2); return v; }
void Ifc2x3::IfcGeometricRepresentationContext::setCoordinateSpaceDimension(int v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
boost::optional< double > Ifc2x3::IfcGeometricRepresentationContext::Precision() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcGeometricRepresentationContext::setPrecision(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
::Ifc2x3::IfcAxis2Placement* Ifc2x3::IfcGeometricRepresentationContext::WorldCoordinateSystem() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcAxis2Placement>(true); }
void Ifc2x3::IfcGeometricRepresentationContext::setWorldCoordinateSystem(::Ifc2x3::IfcAxis2Placement* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcDirection* Ifc2x3::IfcGeometricRepresentationContext::TrueNorth() const { if(get_attribute_value(5).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcDirection>(true); }
void Ifc2x3::IfcGeometricRepresentationContext::setTrueNorth(::Ifc2x3::IfcDirection* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }

::Ifc2x3::IfcGeometricRepresentationSubContext::list::ptr Ifc2x3::IfcGeometricRepresentationContext::HasSubContexts() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[393], 6)->as<IfcGeometricRepresentationSubContext>(); }

const IfcParse::entity& Ifc2x3::IfcGeometricRepresentationContext::declaration() const { return *((IfcParse::entity*)IFC2X3_types[391]); }
const IfcParse::entity& Ifc2x3::IfcGeometricRepresentationContext::Class() { return *((IfcParse::entity*)IFC2X3_types[391]); }
Ifc2x3::IfcGeometricRepresentationContext::IfcGeometricRepresentationContext(IfcEntityInstanceData&& e) : IfcRepresentationContext(std::move(e)) { }
Ifc2x3::IfcGeometricRepresentationContext::IfcGeometricRepresentationContext(boost::optional< std::string > v1_ContextIdentifier, boost::optional< std::string > v2_ContextType, int v3_CoordinateSpaceDimension, boost::optional< double > v4_Precision, ::Ifc2x3::IfcAxis2Placement* v5_WorldCoordinateSystem, ::Ifc2x3::IfcDirection* v6_TrueNorth) : IfcRepresentationContext(IfcEntityInstanceData(in_memory_attribute_storage(6))) {  if (v1_ContextIdentifier) {set_attribute_value(0, (*v1_ContextIdentifier)); } if (v2_ContextType) {set_attribute_value(1, (*v2_ContextType)); }set_attribute_value(2, (v3_CoordinateSpaceDimension)); if (v4_Precision) {set_attribute_value(3, (*v4_Precision)); }set_attribute_value(4, v5_WorldCoordinateSystem ? v5_WorldCoordinateSystem->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_TrueNorth ? v6_TrueNorth->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcGeometricRepresentationItem


const IfcParse::entity& Ifc2x3::IfcGeometricRepresentationItem::declaration() const { return *((IfcParse::entity*)IFC2X3_types[392]); }
const IfcParse::entity& Ifc2x3::IfcGeometricRepresentationItem::Class() { return *((IfcParse::entity*)IFC2X3_types[392]); }
Ifc2x3::IfcGeometricRepresentationItem::IfcGeometricRepresentationItem(IfcEntityInstanceData&& e) : IfcRepresentationItem(std::move(e)) { }
Ifc2x3::IfcGeometricRepresentationItem::IfcGeometricRepresentationItem() : IfcRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(0))) { ; populate_derived(); }

// Function implementations for IfcGeometricRepresentationSubContext
::Ifc2x3::IfcGeometricRepresentationContext* Ifc2x3::IfcGeometricRepresentationSubContext::ParentContext() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcGeometricRepresentationContext>(true); }
void Ifc2x3::IfcGeometricRepresentationSubContext::setParentContext(::Ifc2x3::IfcGeometricRepresentationContext* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
boost::optional< double > Ifc2x3::IfcGeometricRepresentationSubContext::TargetScale() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcGeometricRepresentationSubContext::setTargetScale(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
::Ifc2x3::IfcGeometricProjectionEnum::Value Ifc2x3::IfcGeometricRepresentationSubContext::TargetView() const {  return ::Ifc2x3::IfcGeometricProjectionEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcGeometricRepresentationSubContext::setTargetView(::Ifc2x3::IfcGeometricProjectionEnum::Value v) { set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcGeometricProjectionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }
boost::optional< std::string > Ifc2x3::IfcGeometricRepresentationSubContext::UserDefinedTargetView() const { if(get_attribute_value(9).isNull()) { return boost::none; } std::string v = get_attribute_value(9); return v; }
void Ifc2x3::IfcGeometricRepresentationSubContext::setUserDefinedTargetView(boost::optional< std::string > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }


const IfcParse::entity& Ifc2x3::IfcGeometricRepresentationSubContext::declaration() const { return *((IfcParse::entity*)IFC2X3_types[393]); }
const IfcParse::entity& Ifc2x3::IfcGeometricRepresentationSubContext::Class() { return *((IfcParse::entity*)IFC2X3_types[393]); }
Ifc2x3::IfcGeometricRepresentationSubContext::IfcGeometricRepresentationSubContext(IfcEntityInstanceData&& e) : IfcGeometricRepresentationContext(std::move(e)) { }
Ifc2x3::IfcGeometricRepresentationSubContext::IfcGeometricRepresentationSubContext(boost::optional< std::string > v1_ContextIdentifier, boost::optional< std::string > v2_ContextType, ::Ifc2x3::IfcGeometricRepresentationContext* v7_ParentContext, boost::optional< double > v8_TargetScale, ::Ifc2x3::IfcGeometricProjectionEnum::Value v9_TargetView, boost::optional< std::string > v10_UserDefinedTargetView) : IfcGeometricRepresentationContext(IfcEntityInstanceData(in_memory_attribute_storage(10))) {  if (v1_ContextIdentifier) {set_attribute_value(0, (*v1_ContextIdentifier)); } if (v2_ContextType) {set_attribute_value(1, (*v2_ContextType)); }set_attribute_value(6, v7_ParentContext ? v7_ParentContext->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_TargetScale) {set_attribute_value(7, (*v8_TargetScale)); }set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcGeometricProjectionEnum::Class(),(size_t)v9_TargetView))); if (v10_UserDefinedTargetView) {set_attribute_value(9, (*v10_UserDefinedTargetView)); }; populate_derived(); }

// Function implementations for IfcGeometricSet
aggregate_of< ::Ifc2x3::IfcGeometricSetSelect >::ptr Ifc2x3::IfcGeometricSet::Elements() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcGeometricSetSelect >(); }
void Ifc2x3::IfcGeometricSet::setElements(aggregate_of< ::Ifc2x3::IfcGeometricSetSelect >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcGeometricSet::declaration() const { return *((IfcParse::entity*)IFC2X3_types[394]); }
const IfcParse::entity& Ifc2x3::IfcGeometricSet::Class() { return *((IfcParse::entity*)IFC2X3_types[394]); }
Ifc2x3::IfcGeometricSet::IfcGeometricSet(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcGeometricSet::IfcGeometricSet(aggregate_of< ::Ifc2x3::IfcGeometricSetSelect >::ptr v1_Elements) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Elements)->generalize());; populate_derived(); }

// Function implementations for IfcGrid
aggregate_of< ::Ifc2x3::IfcGridAxis >::ptr Ifc2x3::IfcGrid::UAxes() const {  aggregate_of_instance::ptr es = get_attribute_value(7); return es->as< ::Ifc2x3::IfcGridAxis >(); }
void Ifc2x3::IfcGrid::setUAxes(aggregate_of< ::Ifc2x3::IfcGridAxis >::ptr v) { set_attribute_value(7, (v)->generalize());if constexpr (false)unset_attribute_value(7); }
aggregate_of< ::Ifc2x3::IfcGridAxis >::ptr Ifc2x3::IfcGrid::VAxes() const {  aggregate_of_instance::ptr es = get_attribute_value(8); return es->as< ::Ifc2x3::IfcGridAxis >(); }
void Ifc2x3::IfcGrid::setVAxes(aggregate_of< ::Ifc2x3::IfcGridAxis >::ptr v) { set_attribute_value(8, (v)->generalize());if constexpr (false)unset_attribute_value(8); }
boost::optional< aggregate_of< ::Ifc2x3::IfcGridAxis >::ptr > Ifc2x3::IfcGrid::WAxes() const { if(get_attribute_value(9).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(9); return es->as< ::Ifc2x3::IfcGridAxis >(); }
void Ifc2x3::IfcGrid::setWAxes(boost::optional< aggregate_of< ::Ifc2x3::IfcGridAxis >::ptr > v) { if (v) {set_attribute_value(9, (*v)->generalize());} else {unset_attribute_value(9);} }

::Ifc2x3::IfcRelContainedInSpatialStructure::list::ptr Ifc2x3::IfcGrid::ContainedInStructure() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[698], 4)->as<IfcRelContainedInSpatialStructure>(); }

const IfcParse::entity& Ifc2x3::IfcGrid::declaration() const { return *((IfcParse::entity*)IFC2X3_types[398]); }
const IfcParse::entity& Ifc2x3::IfcGrid::Class() { return *((IfcParse::entity*)IFC2X3_types[398]); }
Ifc2x3::IfcGrid::IfcGrid(IfcEntityInstanceData&& e) : IfcProduct(std::move(e)) { }
Ifc2x3::IfcGrid::IfcGrid(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, aggregate_of< ::Ifc2x3::IfcGridAxis >::ptr v8_UAxes, aggregate_of< ::Ifc2x3::IfcGridAxis >::ptr v9_VAxes, boost::optional< aggregate_of< ::Ifc2x3::IfcGridAxis >::ptr > v10_WAxes) : IfcProduct(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, (v8_UAxes)->generalize());set_attribute_value(8, (v9_VAxes)->generalize()); if (v10_WAxes) {set_attribute_value(9, (*v10_WAxes)->generalize()); }; populate_derived(); }

// Function implementations for IfcGridAxis
boost::optional< std::string > Ifc2x3::IfcGridAxis::AxisTag() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcGridAxis::setAxisTag(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
::Ifc2x3::IfcCurve* Ifc2x3::IfcGridAxis::AxisCurve() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcCurve>(true); }
void Ifc2x3::IfcGridAxis::setAxisCurve(::Ifc2x3::IfcCurve* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
bool Ifc2x3::IfcGridAxis::SameSense() const {  bool v = get_attribute_value(2); return v; }
void Ifc2x3::IfcGridAxis::setSameSense(bool v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }

::Ifc2x3::IfcGrid::list::ptr Ifc2x3::IfcGridAxis::PartOfW() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[398], 9)->as<IfcGrid>(); }
::Ifc2x3::IfcGrid::list::ptr Ifc2x3::IfcGridAxis::PartOfV() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[398], 8)->as<IfcGrid>(); }
::Ifc2x3::IfcGrid::list::ptr Ifc2x3::IfcGridAxis::PartOfU() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[398], 7)->as<IfcGrid>(); }
::Ifc2x3::IfcVirtualGridIntersection::list::ptr Ifc2x3::IfcGridAxis::HasIntersections() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[953], 0)->as<IfcVirtualGridIntersection>(); }

const IfcParse::entity& Ifc2x3::IfcGridAxis::declaration() const { return *((IfcParse::entity*)IFC2X3_types[399]); }
const IfcParse::entity& Ifc2x3::IfcGridAxis::Class() { return *((IfcParse::entity*)IFC2X3_types[399]); }
Ifc2x3::IfcGridAxis::IfcGridAxis(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcGridAxis::IfcGridAxis(boost::optional< std::string > v1_AxisTag, ::Ifc2x3::IfcCurve* v2_AxisCurve, bool v3_SameSense) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) {  if (v1_AxisTag) {set_attribute_value(0, (*v1_AxisTag)); }set_attribute_value(1, v2_AxisCurve ? v2_AxisCurve->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, (v3_SameSense));; populate_derived(); }

// Function implementations for IfcGridPlacement
::Ifc2x3::IfcVirtualGridIntersection* Ifc2x3::IfcGridPlacement::PlacementLocation() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcVirtualGridIntersection>(true); }
void Ifc2x3::IfcGridPlacement::setPlacementLocation(::Ifc2x3::IfcVirtualGridIntersection* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcVirtualGridIntersection* Ifc2x3::IfcGridPlacement::PlacementRefDirection() const { if(get_attribute_value(1).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcVirtualGridIntersection>(true); }
void Ifc2x3::IfcGridPlacement::setPlacementRefDirection(::Ifc2x3::IfcVirtualGridIntersection* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcGridPlacement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[400]); }
const IfcParse::entity& Ifc2x3::IfcGridPlacement::Class() { return *((IfcParse::entity*)IFC2X3_types[400]); }
Ifc2x3::IfcGridPlacement::IfcGridPlacement(IfcEntityInstanceData&& e) : IfcObjectPlacement(std::move(e)) { }
Ifc2x3::IfcGridPlacement::IfcGridPlacement(::Ifc2x3::IfcVirtualGridIntersection* v1_PlacementLocation, ::Ifc2x3::IfcVirtualGridIntersection* v2_PlacementRefDirection) : IfcObjectPlacement(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_PlacementLocation ? v1_PlacementLocation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_PlacementRefDirection ? v2_PlacementRefDirection->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcGroup

::Ifc2x3::IfcRelAssignsToGroup::list::ptr Ifc2x3::IfcGroup::IsGroupedBy() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[672], 6)->as<IfcRelAssignsToGroup>(); }

const IfcParse::entity& Ifc2x3::IfcGroup::declaration() const { return *((IfcParse::entity*)IFC2X3_types[401]); }
const IfcParse::entity& Ifc2x3::IfcGroup::Class() { return *((IfcParse::entity*)IFC2X3_types[401]); }
Ifc2x3::IfcGroup::IfcGroup(IfcEntityInstanceData&& e) : IfcObject(std::move(e)) { }
Ifc2x3::IfcGroup::IfcGroup(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcObject(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }; populate_derived(); }

// Function implementations for IfcHalfSpaceSolid
::Ifc2x3::IfcSurface* Ifc2x3::IfcHalfSpaceSolid::BaseSurface() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcSurface>(true); }
void Ifc2x3::IfcHalfSpaceSolid::setBaseSurface(::Ifc2x3::IfcSurface* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
bool Ifc2x3::IfcHalfSpaceSolid::AgreementFlag() const {  bool v = get_attribute_value(1); return v; }
void Ifc2x3::IfcHalfSpaceSolid::setAgreementFlag(bool v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcHalfSpaceSolid::declaration() const { return *((IfcParse::entity*)IFC2X3_types[402]); }
const IfcParse::entity& Ifc2x3::IfcHalfSpaceSolid::Class() { return *((IfcParse::entity*)IFC2X3_types[402]); }
Ifc2x3::IfcHalfSpaceSolid::IfcHalfSpaceSolid(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcHalfSpaceSolid::IfcHalfSpaceSolid(::Ifc2x3::IfcSurface* v1_BaseSurface, bool v2_AgreementFlag) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_BaseSurface ? v1_BaseSurface->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_AgreementFlag));; populate_derived(); }

// Function implementations for IfcHeatExchangerType
::Ifc2x3::IfcHeatExchangerTypeEnum::Value Ifc2x3::IfcHeatExchangerType::PredefinedType() const {  return ::Ifc2x3::IfcHeatExchangerTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcHeatExchangerType::setPredefinedType(::Ifc2x3::IfcHeatExchangerTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcHeatExchangerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcHeatExchangerType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[404]); }
const IfcParse::entity& Ifc2x3::IfcHeatExchangerType::Class() { return *((IfcParse::entity*)IFC2X3_types[404]); }
Ifc2x3::IfcHeatExchangerType::IfcHeatExchangerType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcHeatExchangerType::IfcHeatExchangerType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcHeatExchangerTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcHeatExchangerTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcHumidifierType
::Ifc2x3::IfcHumidifierTypeEnum::Value Ifc2x3::IfcHumidifierType::PredefinedType() const {  return ::Ifc2x3::IfcHumidifierTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcHumidifierType::setPredefinedType(::Ifc2x3::IfcHumidifierTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcHumidifierTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcHumidifierType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[409]); }
const IfcParse::entity& Ifc2x3::IfcHumidifierType::Class() { return *((IfcParse::entity*)IFC2X3_types[409]); }
Ifc2x3::IfcHumidifierType::IfcHumidifierType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcHumidifierType::IfcHumidifierType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcHumidifierTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcHumidifierTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcHygroscopicMaterialProperties
boost::optional< double > Ifc2x3::IfcHygroscopicMaterialProperties::UpperVaporResistanceFactor() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcHygroscopicMaterialProperties::setUpperVaporResistanceFactor(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcHygroscopicMaterialProperties::LowerVaporResistanceFactor() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcHygroscopicMaterialProperties::setLowerVaporResistanceFactor(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcHygroscopicMaterialProperties::IsothermalMoistureCapacity() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcHygroscopicMaterialProperties::setIsothermalMoistureCapacity(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< double > Ifc2x3::IfcHygroscopicMaterialProperties::VaporPermeability() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcHygroscopicMaterialProperties::setVaporPermeability(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< double > Ifc2x3::IfcHygroscopicMaterialProperties::MoistureDiffusivity() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcHygroscopicMaterialProperties::setMoistureDiffusivity(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }


const IfcParse::entity& Ifc2x3::IfcHygroscopicMaterialProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[411]); }
const IfcParse::entity& Ifc2x3::IfcHygroscopicMaterialProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[411]); }
Ifc2x3::IfcHygroscopicMaterialProperties::IfcHygroscopicMaterialProperties(IfcEntityInstanceData&& e) : IfcMaterialProperties(std::move(e)) { }
Ifc2x3::IfcHygroscopicMaterialProperties::IfcHygroscopicMaterialProperties(::Ifc2x3::IfcMaterial* v1_Material, boost::optional< double > v2_UpperVaporResistanceFactor, boost::optional< double > v3_LowerVaporResistanceFactor, boost::optional< double > v4_IsothermalMoistureCapacity, boost::optional< double > v5_VaporPermeability, boost::optional< double > v6_MoistureDiffusivity) : IfcMaterialProperties(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, v1_Material ? v1_Material->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_UpperVaporResistanceFactor) {set_attribute_value(1, (*v2_UpperVaporResistanceFactor)); } if (v3_LowerVaporResistanceFactor) {set_attribute_value(2, (*v3_LowerVaporResistanceFactor)); } if (v4_IsothermalMoistureCapacity) {set_attribute_value(3, (*v4_IsothermalMoistureCapacity)); } if (v5_VaporPermeability) {set_attribute_value(4, (*v5_VaporPermeability)); } if (v6_MoistureDiffusivity) {set_attribute_value(5, (*v6_MoistureDiffusivity)); }; populate_derived(); }

// Function implementations for IfcIShapeProfileDef
double Ifc2x3::IfcIShapeProfileDef::OverallWidth() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcIShapeProfileDef::setOverallWidth(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
double Ifc2x3::IfcIShapeProfileDef::OverallDepth() const {  double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcIShapeProfileDef::setOverallDepth(double v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
double Ifc2x3::IfcIShapeProfileDef::WebThickness() const {  double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcIShapeProfileDef::setWebThickness(double v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
double Ifc2x3::IfcIShapeProfileDef::FlangeThickness() const {  double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcIShapeProfileDef::setFlangeThickness(double v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
boost::optional< double > Ifc2x3::IfcIShapeProfileDef::FilletRadius() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcIShapeProfileDef::setFilletRadius(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }


const IfcParse::entity& Ifc2x3::IfcIShapeProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[424]); }
const IfcParse::entity& Ifc2x3::IfcIShapeProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[424]); }
Ifc2x3::IfcIShapeProfileDef::IfcIShapeProfileDef(IfcEntityInstanceData&& e) : IfcParameterizedProfileDef(std::move(e)) { }
Ifc2x3::IfcIShapeProfileDef::IfcIShapeProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcAxis2Placement2D* v3_Position, double v4_OverallWidth, double v5_OverallDepth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius) : IfcParameterizedProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_OverallWidth));set_attribute_value(4, (v5_OverallDepth));set_attribute_value(5, (v6_WebThickness));set_attribute_value(6, (v7_FlangeThickness)); if (v8_FilletRadius) {set_attribute_value(7, (*v8_FilletRadius)); }; populate_derived(); }

// Function implementations for IfcImageTexture
std::string Ifc2x3::IfcImageTexture::UrlReference() const {  std::string v = get_attribute_value(4); return v; }
void Ifc2x3::IfcImageTexture::setUrlReference(std::string v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcImageTexture::declaration() const { return *((IfcParse::entity*)IFC2X3_types[414]); }
const IfcParse::entity& Ifc2x3::IfcImageTexture::Class() { return *((IfcParse::entity*)IFC2X3_types[414]); }
Ifc2x3::IfcImageTexture::IfcImageTexture(IfcEntityInstanceData&& e) : IfcSurfaceTexture(std::move(e)) { }
Ifc2x3::IfcImageTexture::IfcImageTexture(bool v1_RepeatS, bool v2_RepeatT, ::Ifc2x3::IfcSurfaceTextureEnum::Value v3_TextureType, ::Ifc2x3::IfcCartesianTransformationOperator2D* v4_TextureTransform, std::string v5_UrlReference) : IfcSurfaceTexture(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_RepeatS));set_attribute_value(1, (v2_RepeatT));set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcSurfaceTextureEnum::Class(),(size_t)v3_TextureType)));set_attribute_value(3, v4_TextureTransform ? v4_TextureTransform->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(4, (v5_UrlReference));; populate_derived(); }

// Function implementations for IfcInventory
::Ifc2x3::IfcInventoryTypeEnum::Value Ifc2x3::IfcInventory::InventoryType() const {  return ::Ifc2x3::IfcInventoryTypeEnum::FromString(get_attribute_value(5)); }
void Ifc2x3::IfcInventory::setInventoryType(::Ifc2x3::IfcInventoryTypeEnum::Value v) { set_attribute_value(5, EnumerationReference(&::Ifc2x3::IfcInventoryTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcActorSelect* Ifc2x3::IfcInventory::Jurisdiction() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcActorSelect>(true); }
void Ifc2x3::IfcInventory::setJurisdiction(::Ifc2x3::IfcActorSelect* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
aggregate_of< ::Ifc2x3::IfcPerson >::ptr Ifc2x3::IfcInventory::ResponsiblePersons() const {  aggregate_of_instance::ptr es = get_attribute_value(7); return es->as< ::Ifc2x3::IfcPerson >(); }
void Ifc2x3::IfcInventory::setResponsiblePersons(aggregate_of< ::Ifc2x3::IfcPerson >::ptr v) { set_attribute_value(7, (v)->generalize());if constexpr (false)unset_attribute_value(7); }
::Ifc2x3::IfcCalendarDate* Ifc2x3::IfcInventory::LastUpdateDate() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(8)))->as<::Ifc2x3::IfcCalendarDate>(true); }
void Ifc2x3::IfcInventory::setLastUpdateDate(::Ifc2x3::IfcCalendarDate* v) { set_attribute_value(8, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(8); }
::Ifc2x3::IfcCostValue* Ifc2x3::IfcInventory::CurrentValue() const { if(get_attribute_value(9).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(9)))->as<::Ifc2x3::IfcCostValue>(true); }
void Ifc2x3::IfcInventory::setCurrentValue(::Ifc2x3::IfcCostValue* v) { set_attribute_value(9, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(9); }
::Ifc2x3::IfcCostValue* Ifc2x3::IfcInventory::OriginalValue() const { if(get_attribute_value(10).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(10)))->as<::Ifc2x3::IfcCostValue>(true); }
void Ifc2x3::IfcInventory::setOriginalValue(::Ifc2x3::IfcCostValue* v) { set_attribute_value(10, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(10); }


const IfcParse::entity& Ifc2x3::IfcInventory::declaration() const { return *((IfcParse::entity*)IFC2X3_types[419]); }
const IfcParse::entity& Ifc2x3::IfcInventory::Class() { return *((IfcParse::entity*)IFC2X3_types[419]); }
Ifc2x3::IfcInventory::IfcInventory(IfcEntityInstanceData&& e) : IfcGroup(std::move(e)) { }
Ifc2x3::IfcInventory::IfcInventory(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcInventoryTypeEnum::Value v6_InventoryType, ::Ifc2x3::IfcActorSelect* v7_Jurisdiction, aggregate_of< ::Ifc2x3::IfcPerson >::ptr v8_ResponsiblePersons, ::Ifc2x3::IfcCalendarDate* v9_LastUpdateDate, ::Ifc2x3::IfcCostValue* v10_CurrentValue, ::Ifc2x3::IfcCostValue* v11_OriginalValue) : IfcGroup(IfcEntityInstanceData(in_memory_attribute_storage(11))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcInventoryTypeEnum::Class(),(size_t)v6_InventoryType)));set_attribute_value(6, v7_Jurisdiction ? v7_Jurisdiction->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, (v8_ResponsiblePersons)->generalize());set_attribute_value(8, v9_LastUpdateDate ? v9_LastUpdateDate->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(9, v10_CurrentValue ? v10_CurrentValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(10, v11_OriginalValue ? v11_OriginalValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcIrregularTimeSeries
aggregate_of< ::Ifc2x3::IfcIrregularTimeSeriesValue >::ptr Ifc2x3::IfcIrregularTimeSeries::Values() const {  aggregate_of_instance::ptr es = get_attribute_value(8); return es->as< ::Ifc2x3::IfcIrregularTimeSeriesValue >(); }
void Ifc2x3::IfcIrregularTimeSeries::setValues(aggregate_of< ::Ifc2x3::IfcIrregularTimeSeriesValue >::ptr v) { set_attribute_value(8, (v)->generalize());if constexpr (false)unset_attribute_value(8); }


const IfcParse::entity& Ifc2x3::IfcIrregularTimeSeries::declaration() const { return *((IfcParse::entity*)IFC2X3_types[422]); }
const IfcParse::entity& Ifc2x3::IfcIrregularTimeSeries::Class() { return *((IfcParse::entity*)IFC2X3_types[422]); }
Ifc2x3::IfcIrregularTimeSeries::IfcIrregularTimeSeries(IfcEntityInstanceData&& e) : IfcTimeSeries(std::move(e)) { }
Ifc2x3::IfcIrregularTimeSeries::IfcIrregularTimeSeries(std::string v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcDateTimeSelect* v3_StartTime, ::Ifc2x3::IfcDateTimeSelect* v4_EndTime, ::Ifc2x3::IfcTimeSeriesDataTypeEnum::Value v5_TimeSeriesDataType, ::Ifc2x3::IfcDataOriginEnum::Value v6_DataOrigin, boost::optional< std::string > v7_UserDefinedDataOrigin, ::Ifc2x3::IfcUnit* v8_Unit, aggregate_of< ::Ifc2x3::IfcIrregularTimeSeriesValue >::ptr v9_Values) : IfcTimeSeries(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_StartTime ? v3_StartTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_EndTime ? v4_EndTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(4, (EnumerationReference(&::Ifc2x3::IfcTimeSeriesDataTypeEnum::Class(),(size_t)v5_TimeSeriesDataType)));set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcDataOriginEnum::Class(),(size_t)v6_DataOrigin))); if (v7_UserDefinedDataOrigin) {set_attribute_value(6, (*v7_UserDefinedDataOrigin)); }set_attribute_value(7, v8_Unit ? v8_Unit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(8, (v9_Values)->generalize());; populate_derived(); }

// Function implementations for IfcIrregularTimeSeriesValue
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcIrregularTimeSeriesValue::TimeStamp() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcIrregularTimeSeriesValue::setTimeStamp(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcValue >::ptr Ifc2x3::IfcIrregularTimeSeriesValue::ListValues() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcValue >(); }
void Ifc2x3::IfcIrregularTimeSeriesValue::setListValues(aggregate_of< ::Ifc2x3::IfcValue >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcIrregularTimeSeriesValue::declaration() const { return *((IfcParse::entity*)IFC2X3_types[423]); }
const IfcParse::entity& Ifc2x3::IfcIrregularTimeSeriesValue::Class() { return *((IfcParse::entity*)IFC2X3_types[423]); }
Ifc2x3::IfcIrregularTimeSeriesValue::IfcIrregularTimeSeriesValue(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcIrregularTimeSeriesValue::IfcIrregularTimeSeriesValue(::Ifc2x3::IfcDateTimeSelect* v1_TimeStamp, aggregate_of< ::Ifc2x3::IfcValue >::ptr v2_ListValues) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_TimeStamp ? v1_TimeStamp->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_ListValues)->generalize());; populate_derived(); }

// Function implementations for IfcJunctionBoxType
::Ifc2x3::IfcJunctionBoxTypeEnum::Value Ifc2x3::IfcJunctionBoxType::PredefinedType() const {  return ::Ifc2x3::IfcJunctionBoxTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcJunctionBoxType::setPredefinedType(::Ifc2x3::IfcJunctionBoxTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcJunctionBoxTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcJunctionBoxType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[426]); }
const IfcParse::entity& Ifc2x3::IfcJunctionBoxType::Class() { return *((IfcParse::entity*)IFC2X3_types[426]); }
Ifc2x3::IfcJunctionBoxType::IfcJunctionBoxType(IfcEntityInstanceData&& e) : IfcFlowFittingType(std::move(e)) { }
Ifc2x3::IfcJunctionBoxType::IfcJunctionBoxType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcJunctionBoxTypeEnum::Value v10_PredefinedType) : IfcFlowFittingType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcJunctionBoxTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcLShapeProfileDef
double Ifc2x3::IfcLShapeProfileDef::Depth() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcLShapeProfileDef::setDepth(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
boost::optional< double > Ifc2x3::IfcLShapeProfileDef::Width() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcLShapeProfileDef::setWidth(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
double Ifc2x3::IfcLShapeProfileDef::Thickness() const {  double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcLShapeProfileDef::setThickness(double v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
boost::optional< double > Ifc2x3::IfcLShapeProfileDef::FilletRadius() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcLShapeProfileDef::setFilletRadius(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
boost::optional< double > Ifc2x3::IfcLShapeProfileDef::EdgeRadius() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcLShapeProfileDef::setEdgeRadius(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
boost::optional< double > Ifc2x3::IfcLShapeProfileDef::LegSlope() const { if(get_attribute_value(8).isNull()) { return boost::none; } double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcLShapeProfileDef::setLegSlope(boost::optional< double > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
boost::optional< double > Ifc2x3::IfcLShapeProfileDef::CentreOfGravityInX() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcLShapeProfileDef::setCentreOfGravityInX(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
boost::optional< double > Ifc2x3::IfcLShapeProfileDef::CentreOfGravityInY() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcLShapeProfileDef::setCentreOfGravityInY(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }


const IfcParse::entity& Ifc2x3::IfcLShapeProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[464]); }
const IfcParse::entity& Ifc2x3::IfcLShapeProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[464]); }
Ifc2x3::IfcLShapeProfileDef::IfcLShapeProfileDef(IfcEntityInstanceData&& e) : IfcParameterizedProfileDef(std::move(e)) { }
Ifc2x3::IfcLShapeProfileDef::IfcLShapeProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcAxis2Placement2D* v3_Position, double v4_Depth, boost::optional< double > v5_Width, double v6_Thickness, boost::optional< double > v7_FilletRadius, boost::optional< double > v8_EdgeRadius, boost::optional< double > v9_LegSlope, boost::optional< double > v10_CentreOfGravityInX, boost::optional< double > v11_CentreOfGravityInY) : IfcParameterizedProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(11))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_Depth)); if (v5_Width) {set_attribute_value(4, (*v5_Width)); }set_attribute_value(5, (v6_Thickness)); if (v7_FilletRadius) {set_attribute_value(6, (*v7_FilletRadius)); } if (v8_EdgeRadius) {set_attribute_value(7, (*v8_EdgeRadius)); } if (v9_LegSlope) {set_attribute_value(8, (*v9_LegSlope)); } if (v10_CentreOfGravityInX) {set_attribute_value(9, (*v10_CentreOfGravityInX)); } if (v11_CentreOfGravityInY) {set_attribute_value(10, (*v11_CentreOfGravityInY)); }; populate_derived(); }

// Function implementations for IfcLaborResource
boost::optional< std::string > Ifc2x3::IfcLaborResource::SkillSet() const { if(get_attribute_value(9).isNull()) { return boost::none; } std::string v = get_attribute_value(9); return v; }
void Ifc2x3::IfcLaborResource::setSkillSet(boost::optional< std::string > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }


const IfcParse::entity& Ifc2x3::IfcLaborResource::declaration() const { return *((IfcParse::entity*)IFC2X3_types[430]); }
const IfcParse::entity& Ifc2x3::IfcLaborResource::Class() { return *((IfcParse::entity*)IFC2X3_types[430]); }
Ifc2x3::IfcLaborResource::IfcLaborResource(IfcEntityInstanceData&& e) : IfcConstructionResource(std::move(e)) { }
Ifc2x3::IfcLaborResource::IfcLaborResource(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< ::Ifc2x3::IfcResourceConsumptionEnum::Value > v8_ResourceConsumption, ::Ifc2x3::IfcMeasureWithUnit* v9_BaseQuantity, boost::optional< std::string > v10_SkillSet) : IfcConstructionResource(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); } if (v6_ResourceIdentifier) {set_attribute_value(5, (*v6_ResourceIdentifier)); } if (v7_ResourceGroup) {set_attribute_value(6, (*v7_ResourceGroup)); } if (v8_ResourceConsumption) {set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcResourceConsumptionEnum::Class(),(size_t)*v8_ResourceConsumption))); }set_attribute_value(8, v9_BaseQuantity ? v9_BaseQuantity->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v10_SkillSet) {set_attribute_value(9, (*v10_SkillSet)); }; populate_derived(); }

// Function implementations for IfcLampType
::Ifc2x3::IfcLampTypeEnum::Value Ifc2x3::IfcLampType::PredefinedType() const {  return ::Ifc2x3::IfcLampTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcLampType::setPredefinedType(::Ifc2x3::IfcLampTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcLampTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcLampType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[431]); }
const IfcParse::entity& Ifc2x3::IfcLampType::Class() { return *((IfcParse::entity*)IFC2X3_types[431]); }
Ifc2x3::IfcLampType::IfcLampType(IfcEntityInstanceData&& e) : IfcFlowTerminalType(std::move(e)) { }
Ifc2x3::IfcLampType::IfcLampType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcLampTypeEnum::Value v10_PredefinedType) : IfcFlowTerminalType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcLampTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcLibraryInformation
std::string Ifc2x3::IfcLibraryInformation::Name() const {  std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcLibraryInformation::setName(std::string v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
boost::optional< std::string > Ifc2x3::IfcLibraryInformation::Version() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcLibraryInformation::setVersion(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
::Ifc2x3::IfcOrganization* Ifc2x3::IfcLibraryInformation::Publisher() const { if(get_attribute_value(2).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcOrganization>(true); }
void Ifc2x3::IfcLibraryInformation::setPublisher(::Ifc2x3::IfcOrganization* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcCalendarDate* Ifc2x3::IfcLibraryInformation::VersionDate() const { if(get_attribute_value(3).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcCalendarDate>(true); }
void Ifc2x3::IfcLibraryInformation::setVersionDate(::Ifc2x3::IfcCalendarDate* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }
boost::optional< aggregate_of< ::Ifc2x3::IfcLibraryReference >::ptr > Ifc2x3::IfcLibraryInformation::LibraryReference() const { if(get_attribute_value(4).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(4); return es->as< ::Ifc2x3::IfcLibraryReference >(); }
void Ifc2x3::IfcLibraryInformation::setLibraryReference(boost::optional< aggregate_of< ::Ifc2x3::IfcLibraryReference >::ptr > v) { if (v) {set_attribute_value(4, (*v)->generalize());} else {unset_attribute_value(4);} }


const IfcParse::entity& Ifc2x3::IfcLibraryInformation::declaration() const { return *((IfcParse::entity*)IFC2X3_types[436]); }
const IfcParse::entity& Ifc2x3::IfcLibraryInformation::Class() { return *((IfcParse::entity*)IFC2X3_types[436]); }
Ifc2x3::IfcLibraryInformation::IfcLibraryInformation(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcLibraryInformation::IfcLibraryInformation(std::string v1_Name, boost::optional< std::string > v2_Version, ::Ifc2x3::IfcOrganization* v3_Publisher, ::Ifc2x3::IfcCalendarDate* v4_VersionDate, boost::optional< aggregate_of< ::Ifc2x3::IfcLibraryReference >::ptr > v5_LibraryReference) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_Name)); if (v2_Version) {set_attribute_value(1, (*v2_Version)); }set_attribute_value(2, v3_Publisher ? v3_Publisher->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_VersionDate ? v4_VersionDate->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v5_LibraryReference) {set_attribute_value(4, (*v5_LibraryReference)->generalize()); }; populate_derived(); }

// Function implementations for IfcLibraryReference

::Ifc2x3::IfcLibraryInformation::list::ptr Ifc2x3::IfcLibraryReference::ReferenceIntoLibrary() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[436], 4)->as<IfcLibraryInformation>(); }

const IfcParse::entity& Ifc2x3::IfcLibraryReference::declaration() const { return *((IfcParse::entity*)IFC2X3_types[437]); }
const IfcParse::entity& Ifc2x3::IfcLibraryReference::Class() { return *((IfcParse::entity*)IFC2X3_types[437]); }
Ifc2x3::IfcLibraryReference::IfcLibraryReference(IfcEntityInstanceData&& e) : IfcExternalReference(std::move(e)) { }
Ifc2x3::IfcLibraryReference::IfcLibraryReference(boost::optional< std::string > v1_Location, boost::optional< std::string > v2_ItemReference, boost::optional< std::string > v3_Name) : IfcExternalReference(IfcEntityInstanceData(in_memory_attribute_storage(3))) {  if (v1_Location) {set_attribute_value(0, (*v1_Location)); } if (v2_ItemReference) {set_attribute_value(1, (*v2_ItemReference)); } if (v3_Name) {set_attribute_value(2, (*v3_Name)); }; populate_derived(); }

// Function implementations for IfcLightDistributionData
double Ifc2x3::IfcLightDistributionData::MainPlaneAngle() const {  double v = get_attribute_value(0); return v; }
void Ifc2x3::IfcLightDistributionData::setMainPlaneAngle(double v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
std::vector< double > /*[1:?]*/ Ifc2x3::IfcLightDistributionData::SecondaryPlaneAngle() const {  std::vector< double > /*[1:?]*/ v = get_attribute_value(1); return v; }
void Ifc2x3::IfcLightDistributionData::setSecondaryPlaneAngle(std::vector< double > /*[1:?]*/ v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
std::vector< double > /*[1:?]*/ Ifc2x3::IfcLightDistributionData::LuminousIntensity() const {  std::vector< double > /*[1:?]*/ v = get_attribute_value(2); return v; }
void Ifc2x3::IfcLightDistributionData::setLuminousIntensity(std::vector< double > /*[1:?]*/ v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcLightDistributionData::declaration() const { return *((IfcParse::entity*)IFC2X3_types[440]); }
const IfcParse::entity& Ifc2x3::IfcLightDistributionData::Class() { return *((IfcParse::entity*)IFC2X3_types[440]); }
Ifc2x3::IfcLightDistributionData::IfcLightDistributionData(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcLightDistributionData::IfcLightDistributionData(double v1_MainPlaneAngle, std::vector< double > /*[1:?]*/ v2_SecondaryPlaneAngle, std::vector< double > /*[1:?]*/ v3_LuminousIntensity) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, (v1_MainPlaneAngle));set_attribute_value(1, (v2_SecondaryPlaneAngle));set_attribute_value(2, (v3_LuminousIntensity));; populate_derived(); }

// Function implementations for IfcLightFixtureType
::Ifc2x3::IfcLightFixtureTypeEnum::Value Ifc2x3::IfcLightFixtureType::PredefinedType() const {  return ::Ifc2x3::IfcLightFixtureTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcLightFixtureType::setPredefinedType(::Ifc2x3::IfcLightFixtureTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcLightFixtureTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcLightFixtureType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[443]); }
const IfcParse::entity& Ifc2x3::IfcLightFixtureType::Class() { return *((IfcParse::entity*)IFC2X3_types[443]); }
Ifc2x3::IfcLightFixtureType::IfcLightFixtureType(IfcEntityInstanceData&& e) : IfcFlowTerminalType(std::move(e)) { }
Ifc2x3::IfcLightFixtureType::IfcLightFixtureType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcLightFixtureTypeEnum::Value v10_PredefinedType) : IfcFlowTerminalType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcLightFixtureTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcLightIntensityDistribution
::Ifc2x3::IfcLightDistributionCurveEnum::Value Ifc2x3::IfcLightIntensityDistribution::LightDistributionCurve() const {  return ::Ifc2x3::IfcLightDistributionCurveEnum::FromString(get_attribute_value(0)); }
void Ifc2x3::IfcLightIntensityDistribution::setLightDistributionCurve(::Ifc2x3::IfcLightDistributionCurveEnum::Value v) { set_attribute_value(0, EnumerationReference(&::Ifc2x3::IfcLightDistributionCurveEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcLightDistributionData >::ptr Ifc2x3::IfcLightIntensityDistribution::DistributionData() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcLightDistributionData >(); }
void Ifc2x3::IfcLightIntensityDistribution::setDistributionData(aggregate_of< ::Ifc2x3::IfcLightDistributionData >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcLightIntensityDistribution::declaration() const { return *((IfcParse::entity*)IFC2X3_types[445]); }
const IfcParse::entity& Ifc2x3::IfcLightIntensityDistribution::Class() { return *((IfcParse::entity*)IFC2X3_types[445]); }
Ifc2x3::IfcLightIntensityDistribution::IfcLightIntensityDistribution(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcLightIntensityDistribution::IfcLightIntensityDistribution(::Ifc2x3::IfcLightDistributionCurveEnum::Value v1_LightDistributionCurve, aggregate_of< ::Ifc2x3::IfcLightDistributionData >::ptr v2_DistributionData) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcLightDistributionCurveEnum::Class(),(size_t)v1_LightDistributionCurve)));set_attribute_value(1, (v2_DistributionData)->generalize());; populate_derived(); }

// Function implementations for IfcLightSource
boost::optional< std::string > Ifc2x3::IfcLightSource::Name() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcLightSource::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
::Ifc2x3::IfcColourRgb* Ifc2x3::IfcLightSource::LightColour() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcColourRgb>(true); }
void Ifc2x3::IfcLightSource::setLightColour(::Ifc2x3::IfcColourRgb* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
boost::optional< double > Ifc2x3::IfcLightSource::AmbientIntensity() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcLightSource::setAmbientIntensity(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcLightSource::Intensity() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcLightSource::setIntensity(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }


const IfcParse::entity& Ifc2x3::IfcLightSource::declaration() const { return *((IfcParse::entity*)IFC2X3_types[446]); }
const IfcParse::entity& Ifc2x3::IfcLightSource::Class() { return *((IfcParse::entity*)IFC2X3_types[446]); }
Ifc2x3::IfcLightSource::IfcLightSource(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcLightSource::IfcLightSource(boost::optional< std::string > v1_Name, ::Ifc2x3::IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(4))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, v2_LightColour ? v2_LightColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_AmbientIntensity) {set_attribute_value(2, (*v3_AmbientIntensity)); } if (v4_Intensity) {set_attribute_value(3, (*v4_Intensity)); }; populate_derived(); }

// Function implementations for IfcLightSourceAmbient


const IfcParse::entity& Ifc2x3::IfcLightSourceAmbient::declaration() const { return *((IfcParse::entity*)IFC2X3_types[447]); }
const IfcParse::entity& Ifc2x3::IfcLightSourceAmbient::Class() { return *((IfcParse::entity*)IFC2X3_types[447]); }
Ifc2x3::IfcLightSourceAmbient::IfcLightSourceAmbient(IfcEntityInstanceData&& e) : IfcLightSource(std::move(e)) { }
Ifc2x3::IfcLightSourceAmbient::IfcLightSourceAmbient(boost::optional< std::string > v1_Name, ::Ifc2x3::IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity) : IfcLightSource(IfcEntityInstanceData(in_memory_attribute_storage(4))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, v2_LightColour ? v2_LightColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_AmbientIntensity) {set_attribute_value(2, (*v3_AmbientIntensity)); } if (v4_Intensity) {set_attribute_value(3, (*v4_Intensity)); }; populate_derived(); }

// Function implementations for IfcLightSourceDirectional
::Ifc2x3::IfcDirection* Ifc2x3::IfcLightSourceDirectional::Orientation() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcDirection>(true); }
void Ifc2x3::IfcLightSourceDirectional::setOrientation(::Ifc2x3::IfcDirection* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcLightSourceDirectional::declaration() const { return *((IfcParse::entity*)IFC2X3_types[448]); }
const IfcParse::entity& Ifc2x3::IfcLightSourceDirectional::Class() { return *((IfcParse::entity*)IFC2X3_types[448]); }
Ifc2x3::IfcLightSourceDirectional::IfcLightSourceDirectional(IfcEntityInstanceData&& e) : IfcLightSource(std::move(e)) { }
Ifc2x3::IfcLightSourceDirectional::IfcLightSourceDirectional(boost::optional< std::string > v1_Name, ::Ifc2x3::IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity, ::Ifc2x3::IfcDirection* v5_Orientation) : IfcLightSource(IfcEntityInstanceData(in_memory_attribute_storage(5))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, v2_LightColour ? v2_LightColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_AmbientIntensity) {set_attribute_value(2, (*v3_AmbientIntensity)); } if (v4_Intensity) {set_attribute_value(3, (*v4_Intensity)); }set_attribute_value(4, v5_Orientation ? v5_Orientation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcLightSourceGoniometric
::Ifc2x3::IfcAxis2Placement3D* Ifc2x3::IfcLightSourceGoniometric::Position() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcAxis2Placement3D>(true); }
void Ifc2x3::IfcLightSourceGoniometric::setPosition(::Ifc2x3::IfcAxis2Placement3D* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcColourRgb* Ifc2x3::IfcLightSourceGoniometric::ColourAppearance() const { if(get_attribute_value(5).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcColourRgb>(true); }
void Ifc2x3::IfcLightSourceGoniometric::setColourAppearance(::Ifc2x3::IfcColourRgb* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }
double Ifc2x3::IfcLightSourceGoniometric::ColourTemperature() const {  double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcLightSourceGoniometric::setColourTemperature(double v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
double Ifc2x3::IfcLightSourceGoniometric::LuminousFlux() const {  double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcLightSourceGoniometric::setLuminousFlux(double v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
::Ifc2x3::IfcLightEmissionSourceEnum::Value Ifc2x3::IfcLightSourceGoniometric::LightEmissionSource() const {  return ::Ifc2x3::IfcLightEmissionSourceEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcLightSourceGoniometric::setLightEmissionSource(::Ifc2x3::IfcLightEmissionSourceEnum::Value v) { set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcLightEmissionSourceEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }
::Ifc2x3::IfcLightDistributionDataSourceSelect* Ifc2x3::IfcLightSourceGoniometric::LightDistributionDataSource() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(9)))->as<::Ifc2x3::IfcLightDistributionDataSourceSelect>(true); }
void Ifc2x3::IfcLightSourceGoniometric::setLightDistributionDataSource(::Ifc2x3::IfcLightDistributionDataSourceSelect* v) { set_attribute_value(9, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcLightSourceGoniometric::declaration() const { return *((IfcParse::entity*)IFC2X3_types[449]); }
const IfcParse::entity& Ifc2x3::IfcLightSourceGoniometric::Class() { return *((IfcParse::entity*)IFC2X3_types[449]); }
Ifc2x3::IfcLightSourceGoniometric::IfcLightSourceGoniometric(IfcEntityInstanceData&& e) : IfcLightSource(std::move(e)) { }
Ifc2x3::IfcLightSourceGoniometric::IfcLightSourceGoniometric(boost::optional< std::string > v1_Name, ::Ifc2x3::IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity, ::Ifc2x3::IfcAxis2Placement3D* v5_Position, ::Ifc2x3::IfcColourRgb* v6_ColourAppearance, double v7_ColourTemperature, double v8_LuminousFlux, ::Ifc2x3::IfcLightEmissionSourceEnum::Value v9_LightEmissionSource, ::Ifc2x3::IfcLightDistributionDataSourceSelect* v10_LightDistributionDataSource) : IfcLightSource(IfcEntityInstanceData(in_memory_attribute_storage(10))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, v2_LightColour ? v2_LightColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_AmbientIntensity) {set_attribute_value(2, (*v3_AmbientIntensity)); } if (v4_Intensity) {set_attribute_value(3, (*v4_Intensity)); }set_attribute_value(4, v5_Position ? v5_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_ColourAppearance ? v6_ColourAppearance->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, (v7_ColourTemperature));set_attribute_value(7, (v8_LuminousFlux));set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcLightEmissionSourceEnum::Class(),(size_t)v9_LightEmissionSource)));set_attribute_value(9, v10_LightDistributionDataSource ? v10_LightDistributionDataSource->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcLightSourcePositional
::Ifc2x3::IfcCartesianPoint* Ifc2x3::IfcLightSourcePositional::Position() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcCartesianPoint>(true); }
void Ifc2x3::IfcLightSourcePositional::setPosition(::Ifc2x3::IfcCartesianPoint* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
double Ifc2x3::IfcLightSourcePositional::Radius() const {  double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcLightSourcePositional::setRadius(double v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
double Ifc2x3::IfcLightSourcePositional::ConstantAttenuation() const {  double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcLightSourcePositional::setConstantAttenuation(double v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
double Ifc2x3::IfcLightSourcePositional::DistanceAttenuation() const {  double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcLightSourcePositional::setDistanceAttenuation(double v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
double Ifc2x3::IfcLightSourcePositional::QuadricAttenuation() const {  double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcLightSourcePositional::setQuadricAttenuation(double v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }


const IfcParse::entity& Ifc2x3::IfcLightSourcePositional::declaration() const { return *((IfcParse::entity*)IFC2X3_types[450]); }
const IfcParse::entity& Ifc2x3::IfcLightSourcePositional::Class() { return *((IfcParse::entity*)IFC2X3_types[450]); }
Ifc2x3::IfcLightSourcePositional::IfcLightSourcePositional(IfcEntityInstanceData&& e) : IfcLightSource(std::move(e)) { }
Ifc2x3::IfcLightSourcePositional::IfcLightSourcePositional(boost::optional< std::string > v1_Name, ::Ifc2x3::IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity, ::Ifc2x3::IfcCartesianPoint* v5_Position, double v6_Radius, double v7_ConstantAttenuation, double v8_DistanceAttenuation, double v9_QuadricAttenuation) : IfcLightSource(IfcEntityInstanceData(in_memory_attribute_storage(9))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, v2_LightColour ? v2_LightColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_AmbientIntensity) {set_attribute_value(2, (*v3_AmbientIntensity)); } if (v4_Intensity) {set_attribute_value(3, (*v4_Intensity)); }set_attribute_value(4, v5_Position ? v5_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, (v6_Radius));set_attribute_value(6, (v7_ConstantAttenuation));set_attribute_value(7, (v8_DistanceAttenuation));set_attribute_value(8, (v9_QuadricAttenuation));; populate_derived(); }

// Function implementations for IfcLightSourceSpot
::Ifc2x3::IfcDirection* Ifc2x3::IfcLightSourceSpot::Orientation() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(9)))->as<::Ifc2x3::IfcDirection>(true); }
void Ifc2x3::IfcLightSourceSpot::setOrientation(::Ifc2x3::IfcDirection* v) { set_attribute_value(9, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(9); }
boost::optional< double > Ifc2x3::IfcLightSourceSpot::ConcentrationExponent() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcLightSourceSpot::setConcentrationExponent(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
double Ifc2x3::IfcLightSourceSpot::SpreadAngle() const {  double v = get_attribute_value(11); return v; }
void Ifc2x3::IfcLightSourceSpot::setSpreadAngle(double v) { set_attribute_value(11, v);if constexpr (false)unset_attribute_value(11); }
double Ifc2x3::IfcLightSourceSpot::BeamWidthAngle() const {  double v = get_attribute_value(12); return v; }
void Ifc2x3::IfcLightSourceSpot::setBeamWidthAngle(double v) { set_attribute_value(12, v);if constexpr (false)unset_attribute_value(12); }


const IfcParse::entity& Ifc2x3::IfcLightSourceSpot::declaration() const { return *((IfcParse::entity*)IFC2X3_types[451]); }
const IfcParse::entity& Ifc2x3::IfcLightSourceSpot::Class() { return *((IfcParse::entity*)IFC2X3_types[451]); }
Ifc2x3::IfcLightSourceSpot::IfcLightSourceSpot(IfcEntityInstanceData&& e) : IfcLightSourcePositional(std::move(e)) { }
Ifc2x3::IfcLightSourceSpot::IfcLightSourceSpot(boost::optional< std::string > v1_Name, ::Ifc2x3::IfcColourRgb* v2_LightColour, boost::optional< double > v3_AmbientIntensity, boost::optional< double > v4_Intensity, ::Ifc2x3::IfcCartesianPoint* v5_Position, double v6_Radius, double v7_ConstantAttenuation, double v8_DistanceAttenuation, double v9_QuadricAttenuation, ::Ifc2x3::IfcDirection* v10_Orientation, boost::optional< double > v11_ConcentrationExponent, double v12_SpreadAngle, double v13_BeamWidthAngle) : IfcLightSourcePositional(IfcEntityInstanceData(in_memory_attribute_storage(13))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, v2_LightColour ? v2_LightColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_AmbientIntensity) {set_attribute_value(2, (*v3_AmbientIntensity)); } if (v4_Intensity) {set_attribute_value(3, (*v4_Intensity)); }set_attribute_value(4, v5_Position ? v5_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, (v6_Radius));set_attribute_value(6, (v7_ConstantAttenuation));set_attribute_value(7, (v8_DistanceAttenuation));set_attribute_value(8, (v9_QuadricAttenuation));set_attribute_value(9, v10_Orientation ? v10_Orientation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v11_ConcentrationExponent) {set_attribute_value(10, (*v11_ConcentrationExponent)); }set_attribute_value(11, (v12_SpreadAngle));set_attribute_value(12, (v13_BeamWidthAngle));; populate_derived(); }

// Function implementations for IfcLine
::Ifc2x3::IfcCartesianPoint* Ifc2x3::IfcLine::Pnt() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcCartesianPoint>(true); }
void Ifc2x3::IfcLine::setPnt(::Ifc2x3::IfcCartesianPoint* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcVector* Ifc2x3::IfcLine::Dir() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcVector>(true); }
void Ifc2x3::IfcLine::setDir(::Ifc2x3::IfcVector* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcLine::declaration() const { return *((IfcParse::entity*)IFC2X3_types[452]); }
const IfcParse::entity& Ifc2x3::IfcLine::Class() { return *((IfcParse::entity*)IFC2X3_types[452]); }
Ifc2x3::IfcLine::IfcLine(IfcEntityInstanceData&& e) : IfcCurve(std::move(e)) { }
Ifc2x3::IfcLine::IfcLine(::Ifc2x3::IfcCartesianPoint* v1_Pnt, ::Ifc2x3::IfcVector* v2_Dir) : IfcCurve(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_Pnt ? v1_Pnt->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_Dir ? v2_Dir->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcLinearDimension


const IfcParse::entity& Ifc2x3::IfcLinearDimension::declaration() const { return *((IfcParse::entity*)IFC2X3_types[453]); }
const IfcParse::entity& Ifc2x3::IfcLinearDimension::Class() { return *((IfcParse::entity*)IFC2X3_types[453]); }
Ifc2x3::IfcLinearDimension::IfcLinearDimension(IfcEntityInstanceData&& e) : IfcDimensionCurveDirectedCallout(std::move(e)) { }
Ifc2x3::IfcLinearDimension::IfcLinearDimension(aggregate_of< ::Ifc2x3::IfcDraughtingCalloutElement >::ptr v1_Contents) : IfcDimensionCurveDirectedCallout(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Contents)->generalize());; populate_derived(); }

// Function implementations for IfcLocalPlacement
::Ifc2x3::IfcObjectPlacement* Ifc2x3::IfcLocalPlacement::PlacementRelTo() const { if(get_attribute_value(0).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcObjectPlacement>(true); }
void Ifc2x3::IfcLocalPlacement::setPlacementRelTo(::Ifc2x3::IfcObjectPlacement* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcAxis2Placement* Ifc2x3::IfcLocalPlacement::RelativePlacement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcAxis2Placement>(true); }
void Ifc2x3::IfcLocalPlacement::setRelativePlacement(::Ifc2x3::IfcAxis2Placement* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcLocalPlacement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[459]); }
const IfcParse::entity& Ifc2x3::IfcLocalPlacement::Class() { return *((IfcParse::entity*)IFC2X3_types[459]); }
Ifc2x3::IfcLocalPlacement::IfcLocalPlacement(IfcEntityInstanceData&& e) : IfcObjectPlacement(std::move(e)) { }
Ifc2x3::IfcLocalPlacement::IfcLocalPlacement(::Ifc2x3::IfcObjectPlacement* v1_PlacementRelTo, ::Ifc2x3::IfcAxis2Placement* v2_RelativePlacement) : IfcObjectPlacement(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_PlacementRelTo ? v1_PlacementRelTo->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_RelativePlacement ? v2_RelativePlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcLocalTime
int Ifc2x3::IfcLocalTime::HourComponent() const {  int v = get_attribute_value(0); return v; }
void Ifc2x3::IfcLocalTime::setHourComponent(int v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
boost::optional< int > Ifc2x3::IfcLocalTime::MinuteComponent() const { if(get_attribute_value(1).isNull()) { return boost::none; } int v = get_attribute_value(1); return v; }
void Ifc2x3::IfcLocalTime::setMinuteComponent(boost::optional< int > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcLocalTime::SecondComponent() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcLocalTime::setSecondComponent(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
::Ifc2x3::IfcCoordinatedUniversalTimeOffset* Ifc2x3::IfcLocalTime::Zone() const { if(get_attribute_value(3).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcCoordinatedUniversalTimeOffset>(true); }
void Ifc2x3::IfcLocalTime::setZone(::Ifc2x3::IfcCoordinatedUniversalTimeOffset* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }
boost::optional< int > Ifc2x3::IfcLocalTime::DaylightSavingOffset() const { if(get_attribute_value(4).isNull()) { return boost::none; } int v = get_attribute_value(4); return v; }
void Ifc2x3::IfcLocalTime::setDaylightSavingOffset(boost::optional< int > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }


const IfcParse::entity& Ifc2x3::IfcLocalTime::declaration() const { return *((IfcParse::entity*)IFC2X3_types[460]); }
const IfcParse::entity& Ifc2x3::IfcLocalTime::Class() { return *((IfcParse::entity*)IFC2X3_types[460]); }
Ifc2x3::IfcLocalTime::IfcLocalTime(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcLocalTime::IfcLocalTime(int v1_HourComponent, boost::optional< int > v2_MinuteComponent, boost::optional< double > v3_SecondComponent, ::Ifc2x3::IfcCoordinatedUniversalTimeOffset* v4_Zone, boost::optional< int > v5_DaylightSavingOffset) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_HourComponent)); if (v2_MinuteComponent) {set_attribute_value(1, (*v2_MinuteComponent)); } if (v3_SecondComponent) {set_attribute_value(2, (*v3_SecondComponent)); }set_attribute_value(3, v4_Zone ? v4_Zone->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v5_DaylightSavingOffset) {set_attribute_value(4, (*v5_DaylightSavingOffset)); }; populate_derived(); }

// Function implementations for IfcLoop


const IfcParse::entity& Ifc2x3::IfcLoop::declaration() const { return *((IfcParse::entity*)IFC2X3_types[463]); }
const IfcParse::entity& Ifc2x3::IfcLoop::Class() { return *((IfcParse::entity*)IFC2X3_types[463]); }
Ifc2x3::IfcLoop::IfcLoop(IfcEntityInstanceData&& e) : IfcTopologicalRepresentationItem(std::move(e)) { }
Ifc2x3::IfcLoop::IfcLoop() : IfcTopologicalRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(0))) { ; populate_derived(); }

// Function implementations for IfcManifoldSolidBrep
::Ifc2x3::IfcClosedShell* Ifc2x3::IfcManifoldSolidBrep::Outer() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcClosedShell>(true); }
void Ifc2x3::IfcManifoldSolidBrep::setOuter(::Ifc2x3::IfcClosedShell* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcManifoldSolidBrep::declaration() const { return *((IfcParse::entity*)IFC2X3_types[470]); }
const IfcParse::entity& Ifc2x3::IfcManifoldSolidBrep::Class() { return *((IfcParse::entity*)IFC2X3_types[470]); }
Ifc2x3::IfcManifoldSolidBrep::IfcManifoldSolidBrep(IfcEntityInstanceData&& e) : IfcSolidModel(std::move(e)) { }
Ifc2x3::IfcManifoldSolidBrep::IfcManifoldSolidBrep(::Ifc2x3::IfcClosedShell* v1_Outer) : IfcSolidModel(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, v1_Outer ? v1_Outer->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcMappedItem
::Ifc2x3::IfcRepresentationMap* Ifc2x3::IfcMappedItem::MappingSource() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcRepresentationMap>(true); }
void Ifc2x3::IfcMappedItem::setMappingSource(::Ifc2x3::IfcRepresentationMap* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcCartesianTransformationOperator* Ifc2x3::IfcMappedItem::MappingTarget() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcCartesianTransformationOperator>(true); }
void Ifc2x3::IfcMappedItem::setMappingTarget(::Ifc2x3::IfcCartesianTransformationOperator* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcMappedItem::declaration() const { return *((IfcParse::entity*)IFC2X3_types[471]); }
const IfcParse::entity& Ifc2x3::IfcMappedItem::Class() { return *((IfcParse::entity*)IFC2X3_types[471]); }
Ifc2x3::IfcMappedItem::IfcMappedItem(IfcEntityInstanceData&& e) : IfcRepresentationItem(std::move(e)) { }
Ifc2x3::IfcMappedItem::IfcMappedItem(::Ifc2x3::IfcRepresentationMap* v1_MappingSource, ::Ifc2x3::IfcCartesianTransformationOperator* v2_MappingTarget) : IfcRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_MappingSource ? v1_MappingSource->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_MappingTarget ? v2_MappingTarget->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcMaterial
std::string Ifc2x3::IfcMaterial::Name() const {  std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcMaterial::setName(std::string v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }

::Ifc2x3::IfcMaterialDefinitionRepresentation::list::ptr Ifc2x3::IfcMaterial::HasRepresentation() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[478], 3)->as<IfcMaterialDefinitionRepresentation>(); }
::Ifc2x3::IfcMaterialClassificationRelationship::list::ptr Ifc2x3::IfcMaterial::ClassifiedAs() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[477], 1)->as<IfcMaterialClassificationRelationship>(); }

const IfcParse::entity& Ifc2x3::IfcMaterial::declaration() const { return *((IfcParse::entity*)IFC2X3_types[476]); }
const IfcParse::entity& Ifc2x3::IfcMaterial::Class() { return *((IfcParse::entity*)IFC2X3_types[476]); }
Ifc2x3::IfcMaterial::IfcMaterial(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcMaterial::IfcMaterial(std::string v1_Name) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Name));; populate_derived(); }

// Function implementations for IfcMaterialClassificationRelationship
aggregate_of< ::Ifc2x3::IfcClassificationNotationSelect >::ptr Ifc2x3::IfcMaterialClassificationRelationship::MaterialClassifications() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcClassificationNotationSelect >(); }
void Ifc2x3::IfcMaterialClassificationRelationship::setMaterialClassifications(aggregate_of< ::Ifc2x3::IfcClassificationNotationSelect >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcMaterial* Ifc2x3::IfcMaterialClassificationRelationship::ClassifiedMaterial() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcMaterial>(true); }
void Ifc2x3::IfcMaterialClassificationRelationship::setClassifiedMaterial(::Ifc2x3::IfcMaterial* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcMaterialClassificationRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[477]); }
const IfcParse::entity& Ifc2x3::IfcMaterialClassificationRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[477]); }
Ifc2x3::IfcMaterialClassificationRelationship::IfcMaterialClassificationRelationship(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcMaterialClassificationRelationship::IfcMaterialClassificationRelationship(aggregate_of< ::Ifc2x3::IfcClassificationNotationSelect >::ptr v1_MaterialClassifications, ::Ifc2x3::IfcMaterial* v2_ClassifiedMaterial) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (v1_MaterialClassifications)->generalize());set_attribute_value(1, v2_ClassifiedMaterial ? v2_ClassifiedMaterial->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcMaterialDefinitionRepresentation
::Ifc2x3::IfcMaterial* Ifc2x3::IfcMaterialDefinitionRepresentation::RepresentedMaterial() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcMaterial>(true); }
void Ifc2x3::IfcMaterialDefinitionRepresentation::setRepresentedMaterial(::Ifc2x3::IfcMaterial* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcMaterialDefinitionRepresentation::declaration() const { return *((IfcParse::entity*)IFC2X3_types[478]); }
const IfcParse::entity& Ifc2x3::IfcMaterialDefinitionRepresentation::Class() { return *((IfcParse::entity*)IFC2X3_types[478]); }
Ifc2x3::IfcMaterialDefinitionRepresentation::IfcMaterialDefinitionRepresentation(IfcEntityInstanceData&& e) : IfcProductRepresentation(std::move(e)) { }
Ifc2x3::IfcMaterialDefinitionRepresentation::IfcMaterialDefinitionRepresentation(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, aggregate_of< ::Ifc2x3::IfcRepresentation >::ptr v3_Representations, ::Ifc2x3::IfcMaterial* v4_RepresentedMaterial) : IfcProductRepresentation(IfcEntityInstanceData(in_memory_attribute_storage(4))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_Representations)->generalize());set_attribute_value(3, v4_RepresentedMaterial ? v4_RepresentedMaterial->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcMaterialLayer
::Ifc2x3::IfcMaterial* Ifc2x3::IfcMaterialLayer::Material() const { if(get_attribute_value(0).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcMaterial>(true); }
void Ifc2x3::IfcMaterialLayer::setMaterial(::Ifc2x3::IfcMaterial* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
double Ifc2x3::IfcMaterialLayer::LayerThickness() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcMaterialLayer::setLayerThickness(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
boost::optional< boost::logic::tribool > Ifc2x3::IfcMaterialLayer::IsVentilated() const { if(get_attribute_value(2).isNull()) { return boost::none; } boost::logic::tribool v = get_attribute_value(2); return v; }
void Ifc2x3::IfcMaterialLayer::setIsVentilated(boost::optional< boost::logic::tribool > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }

::Ifc2x3::IfcMaterialLayerSet::list::ptr Ifc2x3::IfcMaterialLayer::ToMaterialLayerSet() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[480], 0)->as<IfcMaterialLayerSet>(); }

const IfcParse::entity& Ifc2x3::IfcMaterialLayer::declaration() const { return *((IfcParse::entity*)IFC2X3_types[479]); }
const IfcParse::entity& Ifc2x3::IfcMaterialLayer::Class() { return *((IfcParse::entity*)IFC2X3_types[479]); }
Ifc2x3::IfcMaterialLayer::IfcMaterialLayer(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcMaterialLayer::IfcMaterialLayer(::Ifc2x3::IfcMaterial* v1_Material, double v2_LayerThickness, boost::optional< boost::logic::tribool > v3_IsVentilated) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_Material ? v1_Material->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_LayerThickness)); if (v3_IsVentilated) {set_attribute_value(2, (*v3_IsVentilated)); }; populate_derived(); }

// Function implementations for IfcMaterialLayerSet
aggregate_of< ::Ifc2x3::IfcMaterialLayer >::ptr Ifc2x3::IfcMaterialLayerSet::MaterialLayers() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcMaterialLayer >(); }
void Ifc2x3::IfcMaterialLayerSet::setMaterialLayers(aggregate_of< ::Ifc2x3::IfcMaterialLayer >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }
boost::optional< std::string > Ifc2x3::IfcMaterialLayerSet::LayerSetName() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcMaterialLayerSet::setLayerSetName(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }


const IfcParse::entity& Ifc2x3::IfcMaterialLayerSet::declaration() const { return *((IfcParse::entity*)IFC2X3_types[480]); }
const IfcParse::entity& Ifc2x3::IfcMaterialLayerSet::Class() { return *((IfcParse::entity*)IFC2X3_types[480]); }
Ifc2x3::IfcMaterialLayerSet::IfcMaterialLayerSet(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcMaterialLayerSet::IfcMaterialLayerSet(aggregate_of< ::Ifc2x3::IfcMaterialLayer >::ptr v1_MaterialLayers, boost::optional< std::string > v2_LayerSetName) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (v1_MaterialLayers)->generalize()); if (v2_LayerSetName) {set_attribute_value(1, (*v2_LayerSetName)); }; populate_derived(); }

// Function implementations for IfcMaterialLayerSetUsage
::Ifc2x3::IfcMaterialLayerSet* Ifc2x3::IfcMaterialLayerSetUsage::ForLayerSet() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcMaterialLayerSet>(true); }
void Ifc2x3::IfcMaterialLayerSetUsage::setForLayerSet(::Ifc2x3::IfcMaterialLayerSet* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcLayerSetDirectionEnum::Value Ifc2x3::IfcMaterialLayerSetUsage::LayerSetDirection() const {  return ::Ifc2x3::IfcLayerSetDirectionEnum::FromString(get_attribute_value(1)); }
void Ifc2x3::IfcMaterialLayerSetUsage::setLayerSetDirection(::Ifc2x3::IfcLayerSetDirectionEnum::Value v) { set_attribute_value(1, EnumerationReference(&::Ifc2x3::IfcLayerSetDirectionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcDirectionSenseEnum::Value Ifc2x3::IfcMaterialLayerSetUsage::DirectionSense() const {  return ::Ifc2x3::IfcDirectionSenseEnum::FromString(get_attribute_value(2)); }
void Ifc2x3::IfcMaterialLayerSetUsage::setDirectionSense(::Ifc2x3::IfcDirectionSenseEnum::Value v) { set_attribute_value(2, EnumerationReference(&::Ifc2x3::IfcDirectionSenseEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(2); }
double Ifc2x3::IfcMaterialLayerSetUsage::OffsetFromReferenceLine() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcMaterialLayerSetUsage::setOffsetFromReferenceLine(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcMaterialLayerSetUsage::declaration() const { return *((IfcParse::entity*)IFC2X3_types[481]); }
const IfcParse::entity& Ifc2x3::IfcMaterialLayerSetUsage::Class() { return *((IfcParse::entity*)IFC2X3_types[481]); }
Ifc2x3::IfcMaterialLayerSetUsage::IfcMaterialLayerSetUsage(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcMaterialLayerSetUsage::IfcMaterialLayerSetUsage(::Ifc2x3::IfcMaterialLayerSet* v1_ForLayerSet, ::Ifc2x3::IfcLayerSetDirectionEnum::Value v2_LayerSetDirection, ::Ifc2x3::IfcDirectionSenseEnum::Value v3_DirectionSense, double v4_OffsetFromReferenceLine) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_ForLayerSet ? v1_ForLayerSet->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (EnumerationReference(&::Ifc2x3::IfcLayerSetDirectionEnum::Class(),(size_t)v2_LayerSetDirection)));set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcDirectionSenseEnum::Class(),(size_t)v3_DirectionSense)));set_attribute_value(3, (v4_OffsetFromReferenceLine));; populate_derived(); }

// Function implementations for IfcMaterialList
aggregate_of< ::Ifc2x3::IfcMaterial >::ptr Ifc2x3::IfcMaterialList::Materials() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcMaterial >(); }
void Ifc2x3::IfcMaterialList::setMaterials(aggregate_of< ::Ifc2x3::IfcMaterial >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcMaterialList::declaration() const { return *((IfcParse::entity*)IFC2X3_types[482]); }
const IfcParse::entity& Ifc2x3::IfcMaterialList::Class() { return *((IfcParse::entity*)IFC2X3_types[482]); }
Ifc2x3::IfcMaterialList::IfcMaterialList(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcMaterialList::IfcMaterialList(aggregate_of< ::Ifc2x3::IfcMaterial >::ptr v1_Materials) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Materials)->generalize());; populate_derived(); }

// Function implementations for IfcMaterialProperties
::Ifc2x3::IfcMaterial* Ifc2x3::IfcMaterialProperties::Material() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcMaterial>(true); }
void Ifc2x3::IfcMaterialProperties::setMaterial(::Ifc2x3::IfcMaterial* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcMaterialProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[483]); }
const IfcParse::entity& Ifc2x3::IfcMaterialProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[483]); }
Ifc2x3::IfcMaterialProperties::IfcMaterialProperties(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcMaterialProperties::IfcMaterialProperties(::Ifc2x3::IfcMaterial* v1_Material) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, v1_Material ? v1_Material->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcMeasureWithUnit
::Ifc2x3::IfcValue* Ifc2x3::IfcMeasureWithUnit::ValueComponent() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcValue>(true); }
void Ifc2x3::IfcMeasureWithUnit::setValueComponent(::Ifc2x3::IfcValue* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcUnit* Ifc2x3::IfcMeasureWithUnit::UnitComponent() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcUnit>(true); }
void Ifc2x3::IfcMeasureWithUnit::setUnitComponent(::Ifc2x3::IfcUnit* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcMeasureWithUnit::declaration() const { return *((IfcParse::entity*)IFC2X3_types[486]); }
const IfcParse::entity& Ifc2x3::IfcMeasureWithUnit::Class() { return *((IfcParse::entity*)IFC2X3_types[486]); }
Ifc2x3::IfcMeasureWithUnit::IfcMeasureWithUnit(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcMeasureWithUnit::IfcMeasureWithUnit(::Ifc2x3::IfcValue* v1_ValueComponent, ::Ifc2x3::IfcUnit* v2_UnitComponent) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_ValueComponent ? v1_ValueComponent->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_UnitComponent ? v2_UnitComponent->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcMechanicalConcreteMaterialProperties
boost::optional< double > Ifc2x3::IfcMechanicalConcreteMaterialProperties::CompressiveStrength() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcMechanicalConcreteMaterialProperties::setCompressiveStrength(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
boost::optional< double > Ifc2x3::IfcMechanicalConcreteMaterialProperties::MaxAggregateSize() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcMechanicalConcreteMaterialProperties::setMaxAggregateSize(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
boost::optional< std::string > Ifc2x3::IfcMechanicalConcreteMaterialProperties::AdmixturesDescription() const { if(get_attribute_value(8).isNull()) { return boost::none; } std::string v = get_attribute_value(8); return v; }
void Ifc2x3::IfcMechanicalConcreteMaterialProperties::setAdmixturesDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
boost::optional< std::string > Ifc2x3::IfcMechanicalConcreteMaterialProperties::Workability() const { if(get_attribute_value(9).isNull()) { return boost::none; } std::string v = get_attribute_value(9); return v; }
void Ifc2x3::IfcMechanicalConcreteMaterialProperties::setWorkability(boost::optional< std::string > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
boost::optional< double > Ifc2x3::IfcMechanicalConcreteMaterialProperties::ProtectivePoreRatio() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcMechanicalConcreteMaterialProperties::setProtectivePoreRatio(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
boost::optional< std::string > Ifc2x3::IfcMechanicalConcreteMaterialProperties::WaterImpermeability() const { if(get_attribute_value(11).isNull()) { return boost::none; } std::string v = get_attribute_value(11); return v; }
void Ifc2x3::IfcMechanicalConcreteMaterialProperties::setWaterImpermeability(boost::optional< std::string > v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }


const IfcParse::entity& Ifc2x3::IfcMechanicalConcreteMaterialProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[487]); }
const IfcParse::entity& Ifc2x3::IfcMechanicalConcreteMaterialProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[487]); }
Ifc2x3::IfcMechanicalConcreteMaterialProperties::IfcMechanicalConcreteMaterialProperties(IfcEntityInstanceData&& e) : IfcMechanicalMaterialProperties(std::move(e)) { }
Ifc2x3::IfcMechanicalConcreteMaterialProperties::IfcMechanicalConcreteMaterialProperties(::Ifc2x3::IfcMaterial* v1_Material, boost::optional< double > v2_DynamicViscosity, boost::optional< double > v3_YoungModulus, boost::optional< double > v4_ShearModulus, boost::optional< double > v5_PoissonRatio, boost::optional< double > v6_ThermalExpansionCoefficient, boost::optional< double > v7_CompressiveStrength, boost::optional< double > v8_MaxAggregateSize, boost::optional< std::string > v9_AdmixturesDescription, boost::optional< std::string > v10_Workability, boost::optional< double > v11_ProtectivePoreRatio, boost::optional< std::string > v12_WaterImpermeability) : IfcMechanicalMaterialProperties(IfcEntityInstanceData(in_memory_attribute_storage(12))) { set_attribute_value(0, v1_Material ? v1_Material->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_DynamicViscosity) {set_attribute_value(1, (*v2_DynamicViscosity)); } if (v3_YoungModulus) {set_attribute_value(2, (*v3_YoungModulus)); } if (v4_ShearModulus) {set_attribute_value(3, (*v4_ShearModulus)); } if (v5_PoissonRatio) {set_attribute_value(4, (*v5_PoissonRatio)); } if (v6_ThermalExpansionCoefficient) {set_attribute_value(5, (*v6_ThermalExpansionCoefficient)); } if (v7_CompressiveStrength) {set_attribute_value(6, (*v7_CompressiveStrength)); } if (v8_MaxAggregateSize) {set_attribute_value(7, (*v8_MaxAggregateSize)); } if (v9_AdmixturesDescription) {set_attribute_value(8, (*v9_AdmixturesDescription)); } if (v10_Workability) {set_attribute_value(9, (*v10_Workability)); } if (v11_ProtectivePoreRatio) {set_attribute_value(10, (*v11_ProtectivePoreRatio)); } if (v12_WaterImpermeability) {set_attribute_value(11, (*v12_WaterImpermeability)); }; populate_derived(); }

// Function implementations for IfcMechanicalFastener
boost::optional< double > Ifc2x3::IfcMechanicalFastener::NominalDiameter() const { if(get_attribute_value(8).isNull()) { return boost::none; } double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcMechanicalFastener::setNominalDiameter(boost::optional< double > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
boost::optional< double > Ifc2x3::IfcMechanicalFastener::NominalLength() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcMechanicalFastener::setNominalLength(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }


const IfcParse::entity& Ifc2x3::IfcMechanicalFastener::declaration() const { return *((IfcParse::entity*)IFC2X3_types[488]); }
const IfcParse::entity& Ifc2x3::IfcMechanicalFastener::Class() { return *((IfcParse::entity*)IFC2X3_types[488]); }
Ifc2x3::IfcMechanicalFastener::IfcMechanicalFastener(IfcEntityInstanceData&& e) : IfcFastener(std::move(e)) { }
Ifc2x3::IfcMechanicalFastener::IfcMechanicalFastener(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_NominalDiameter, boost::optional< double > v10_NominalLength) : IfcFastener(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_NominalDiameter) {set_attribute_value(8, (*v9_NominalDiameter)); } if (v10_NominalLength) {set_attribute_value(9, (*v10_NominalLength)); }; populate_derived(); }

// Function implementations for IfcMechanicalFastenerType


const IfcParse::entity& Ifc2x3::IfcMechanicalFastenerType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[489]); }
const IfcParse::entity& Ifc2x3::IfcMechanicalFastenerType::Class() { return *((IfcParse::entity*)IFC2X3_types[489]); }
Ifc2x3::IfcMechanicalFastenerType::IfcMechanicalFastenerType(IfcEntityInstanceData&& e) : IfcFastenerType(std::move(e)) { }
Ifc2x3::IfcMechanicalFastenerType::IfcMechanicalFastenerType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcFastenerType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcMechanicalMaterialProperties
boost::optional< double > Ifc2x3::IfcMechanicalMaterialProperties::DynamicViscosity() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcMechanicalMaterialProperties::setDynamicViscosity(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcMechanicalMaterialProperties::YoungModulus() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcMechanicalMaterialProperties::setYoungModulus(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcMechanicalMaterialProperties::ShearModulus() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcMechanicalMaterialProperties::setShearModulus(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< double > Ifc2x3::IfcMechanicalMaterialProperties::PoissonRatio() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcMechanicalMaterialProperties::setPoissonRatio(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< double > Ifc2x3::IfcMechanicalMaterialProperties::ThermalExpansionCoefficient() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcMechanicalMaterialProperties::setThermalExpansionCoefficient(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }


const IfcParse::entity& Ifc2x3::IfcMechanicalMaterialProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[490]); }
const IfcParse::entity& Ifc2x3::IfcMechanicalMaterialProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[490]); }
Ifc2x3::IfcMechanicalMaterialProperties::IfcMechanicalMaterialProperties(IfcEntityInstanceData&& e) : IfcMaterialProperties(std::move(e)) { }
Ifc2x3::IfcMechanicalMaterialProperties::IfcMechanicalMaterialProperties(::Ifc2x3::IfcMaterial* v1_Material, boost::optional< double > v2_DynamicViscosity, boost::optional< double > v3_YoungModulus, boost::optional< double > v4_ShearModulus, boost::optional< double > v5_PoissonRatio, boost::optional< double > v6_ThermalExpansionCoefficient) : IfcMaterialProperties(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, v1_Material ? v1_Material->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_DynamicViscosity) {set_attribute_value(1, (*v2_DynamicViscosity)); } if (v3_YoungModulus) {set_attribute_value(2, (*v3_YoungModulus)); } if (v4_ShearModulus) {set_attribute_value(3, (*v4_ShearModulus)); } if (v5_PoissonRatio) {set_attribute_value(4, (*v5_PoissonRatio)); } if (v6_ThermalExpansionCoefficient) {set_attribute_value(5, (*v6_ThermalExpansionCoefficient)); }; populate_derived(); }

// Function implementations for IfcMechanicalSteelMaterialProperties
boost::optional< double > Ifc2x3::IfcMechanicalSteelMaterialProperties::YieldStress() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcMechanicalSteelMaterialProperties::setYieldStress(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
boost::optional< double > Ifc2x3::IfcMechanicalSteelMaterialProperties::UltimateStress() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcMechanicalSteelMaterialProperties::setUltimateStress(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
boost::optional< double > Ifc2x3::IfcMechanicalSteelMaterialProperties::UltimateStrain() const { if(get_attribute_value(8).isNull()) { return boost::none; } double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcMechanicalSteelMaterialProperties::setUltimateStrain(boost::optional< double > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
boost::optional< double > Ifc2x3::IfcMechanicalSteelMaterialProperties::HardeningModule() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcMechanicalSteelMaterialProperties::setHardeningModule(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
boost::optional< double > Ifc2x3::IfcMechanicalSteelMaterialProperties::ProportionalStress() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcMechanicalSteelMaterialProperties::setProportionalStress(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
boost::optional< double > Ifc2x3::IfcMechanicalSteelMaterialProperties::PlasticStrain() const { if(get_attribute_value(11).isNull()) { return boost::none; } double v = get_attribute_value(11); return v; }
void Ifc2x3::IfcMechanicalSteelMaterialProperties::setPlasticStrain(boost::optional< double > v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
boost::optional< aggregate_of< ::Ifc2x3::IfcRelaxation >::ptr > Ifc2x3::IfcMechanicalSteelMaterialProperties::Relaxations() const { if(get_attribute_value(12).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(12); return es->as< ::Ifc2x3::IfcRelaxation >(); }
void Ifc2x3::IfcMechanicalSteelMaterialProperties::setRelaxations(boost::optional< aggregate_of< ::Ifc2x3::IfcRelaxation >::ptr > v) { if (v) {set_attribute_value(12, (*v)->generalize());} else {unset_attribute_value(12);} }


const IfcParse::entity& Ifc2x3::IfcMechanicalSteelMaterialProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[491]); }
const IfcParse::entity& Ifc2x3::IfcMechanicalSteelMaterialProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[491]); }
Ifc2x3::IfcMechanicalSteelMaterialProperties::IfcMechanicalSteelMaterialProperties(IfcEntityInstanceData&& e) : IfcMechanicalMaterialProperties(std::move(e)) { }
Ifc2x3::IfcMechanicalSteelMaterialProperties::IfcMechanicalSteelMaterialProperties(::Ifc2x3::IfcMaterial* v1_Material, boost::optional< double > v2_DynamicViscosity, boost::optional< double > v3_YoungModulus, boost::optional< double > v4_ShearModulus, boost::optional< double > v5_PoissonRatio, boost::optional< double > v6_ThermalExpansionCoefficient, boost::optional< double > v7_YieldStress, boost::optional< double > v8_UltimateStress, boost::optional< double > v9_UltimateStrain, boost::optional< double > v10_HardeningModule, boost::optional< double > v11_ProportionalStress, boost::optional< double > v12_PlasticStrain, boost::optional< aggregate_of< ::Ifc2x3::IfcRelaxation >::ptr > v13_Relaxations) : IfcMechanicalMaterialProperties(IfcEntityInstanceData(in_memory_attribute_storage(13))) { set_attribute_value(0, v1_Material ? v1_Material->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_DynamicViscosity) {set_attribute_value(1, (*v2_DynamicViscosity)); } if (v3_YoungModulus) {set_attribute_value(2, (*v3_YoungModulus)); } if (v4_ShearModulus) {set_attribute_value(3, (*v4_ShearModulus)); } if (v5_PoissonRatio) {set_attribute_value(4, (*v5_PoissonRatio)); } if (v6_ThermalExpansionCoefficient) {set_attribute_value(5, (*v6_ThermalExpansionCoefficient)); } if (v7_YieldStress) {set_attribute_value(6, (*v7_YieldStress)); } if (v8_UltimateStress) {set_attribute_value(7, (*v8_UltimateStress)); } if (v9_UltimateStrain) {set_attribute_value(8, (*v9_UltimateStrain)); } if (v10_HardeningModule) {set_attribute_value(9, (*v10_HardeningModule)); } if (v11_ProportionalStress) {set_attribute_value(10, (*v11_ProportionalStress)); } if (v12_PlasticStrain) {set_attribute_value(11, (*v12_PlasticStrain)); } if (v13_Relaxations) {set_attribute_value(12, (*v13_Relaxations)->generalize()); }; populate_derived(); }

// Function implementations for IfcMember


const IfcParse::entity& Ifc2x3::IfcMember::declaration() const { return *((IfcParse::entity*)IFC2X3_types[492]); }
const IfcParse::entity& Ifc2x3::IfcMember::Class() { return *((IfcParse::entity*)IFC2X3_types[492]); }
Ifc2x3::IfcMember::IfcMember(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcMember::IfcMember(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcMemberType
::Ifc2x3::IfcMemberTypeEnum::Value Ifc2x3::IfcMemberType::PredefinedType() const {  return ::Ifc2x3::IfcMemberTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcMemberType::setPredefinedType(::Ifc2x3::IfcMemberTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcMemberTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcMemberType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[493]); }
const IfcParse::entity& Ifc2x3::IfcMemberType::Class() { return *((IfcParse::entity*)IFC2X3_types[493]); }
Ifc2x3::IfcMemberType::IfcMemberType(IfcEntityInstanceData&& e) : IfcBuildingElementType(std::move(e)) { }
Ifc2x3::IfcMemberType::IfcMemberType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcMemberTypeEnum::Value v10_PredefinedType) : IfcBuildingElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcMemberTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcMetric
::Ifc2x3::IfcBenchmarkEnum::Value Ifc2x3::IfcMetric::Benchmark() const {  return ::Ifc2x3::IfcBenchmarkEnum::FromString(get_attribute_value(7)); }
void Ifc2x3::IfcMetric::setBenchmark(::Ifc2x3::IfcBenchmarkEnum::Value v) { set_attribute_value(7, EnumerationReference(&::Ifc2x3::IfcBenchmarkEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }
boost::optional< std::string > Ifc2x3::IfcMetric::ValueSource() const { if(get_attribute_value(8).isNull()) { return boost::none; } std::string v = get_attribute_value(8); return v; }
void Ifc2x3::IfcMetric::setValueSource(boost::optional< std::string > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
::Ifc2x3::IfcMetricValueSelect* Ifc2x3::IfcMetric::DataValue() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(9)))->as<::Ifc2x3::IfcMetricValueSelect>(true); }
void Ifc2x3::IfcMetric::setDataValue(::Ifc2x3::IfcMetricValueSelect* v) { set_attribute_value(9, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcMetric::declaration() const { return *((IfcParse::entity*)IFC2X3_types[495]); }
const IfcParse::entity& Ifc2x3::IfcMetric::Class() { return *((IfcParse::entity*)IFC2X3_types[495]); }
Ifc2x3::IfcMetric::IfcMetric(IfcEntityInstanceData&& e) : IfcConstraint(std::move(e)) { }
Ifc2x3::IfcMetric::IfcMetric(std::string v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcConstraintEnum::Value v3_ConstraintGrade, boost::optional< std::string > v4_ConstraintSource, ::Ifc2x3::IfcActorSelect* v5_CreatingActor, ::Ifc2x3::IfcDateTimeSelect* v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade, ::Ifc2x3::IfcBenchmarkEnum::Value v8_Benchmark, boost::optional< std::string > v9_ValueSource, ::Ifc2x3::IfcMetricValueSelect* v10_DataValue) : IfcConstraint(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcConstraintEnum::Class(),(size_t)v3_ConstraintGrade))); if (v4_ConstraintSource) {set_attribute_value(3, (*v4_ConstraintSource)); }set_attribute_value(4, v5_CreatingActor ? v5_CreatingActor->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_CreationTime ? v6_CreationTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v7_UserDefinedGrade) {set_attribute_value(6, (*v7_UserDefinedGrade)); }set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcBenchmarkEnum::Class(),(size_t)v8_Benchmark))); if (v9_ValueSource) {set_attribute_value(8, (*v9_ValueSource)); }set_attribute_value(9, v10_DataValue ? v10_DataValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcMonetaryUnit
::Ifc2x3::IfcCurrencyEnum::Value Ifc2x3::IfcMonetaryUnit::Currency() const {  return ::Ifc2x3::IfcCurrencyEnum::FromString(get_attribute_value(0)); }
void Ifc2x3::IfcMonetaryUnit::setCurrency(::Ifc2x3::IfcCurrencyEnum::Value v) { set_attribute_value(0, EnumerationReference(&::Ifc2x3::IfcCurrencyEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcMonetaryUnit::declaration() const { return *((IfcParse::entity*)IFC2X3_types[506]); }
const IfcParse::entity& Ifc2x3::IfcMonetaryUnit::Class() { return *((IfcParse::entity*)IFC2X3_types[506]); }
Ifc2x3::IfcMonetaryUnit::IfcMonetaryUnit(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcMonetaryUnit::IfcMonetaryUnit(::Ifc2x3::IfcCurrencyEnum::Value v1_Currency) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcCurrencyEnum::Class(),(size_t)v1_Currency)));; populate_derived(); }

// Function implementations for IfcMotorConnectionType
::Ifc2x3::IfcMotorConnectionTypeEnum::Value Ifc2x3::IfcMotorConnectionType::PredefinedType() const {  return ::Ifc2x3::IfcMotorConnectionTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcMotorConnectionType::setPredefinedType(::Ifc2x3::IfcMotorConnectionTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcMotorConnectionTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcMotorConnectionType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[508]); }
const IfcParse::entity& Ifc2x3::IfcMotorConnectionType::Class() { return *((IfcParse::entity*)IFC2X3_types[508]); }
Ifc2x3::IfcMotorConnectionType::IfcMotorConnectionType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcMotorConnectionType::IfcMotorConnectionType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcMotorConnectionTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcMotorConnectionTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcMove
::Ifc2x3::IfcSpatialStructureElement* Ifc2x3::IfcMove::MoveFrom() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(10)))->as<::Ifc2x3::IfcSpatialStructureElement>(true); }
void Ifc2x3::IfcMove::setMoveFrom(::Ifc2x3::IfcSpatialStructureElement* v) { set_attribute_value(10, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(10); }
::Ifc2x3::IfcSpatialStructureElement* Ifc2x3::IfcMove::MoveTo() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(11)))->as<::Ifc2x3::IfcSpatialStructureElement>(true); }
void Ifc2x3::IfcMove::setMoveTo(::Ifc2x3::IfcSpatialStructureElement* v) { set_attribute_value(11, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(11); }
boost::optional< std::vector< std::string > /*[1:?]*/ > Ifc2x3::IfcMove::PunchList() const { if(get_attribute_value(12).isNull()) { return boost::none; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(12); return v; }
void Ifc2x3::IfcMove::setPunchList(boost::optional< std::vector< std::string > /*[1:?]*/ > v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }


const IfcParse::entity& Ifc2x3::IfcMove::declaration() const { return *((IfcParse::entity*)IFC2X3_types[510]); }
const IfcParse::entity& Ifc2x3::IfcMove::Class() { return *((IfcParse::entity*)IFC2X3_types[510]); }
Ifc2x3::IfcMove::IfcMove(IfcEntityInstanceData&& e) : IfcTask(std::move(e)) { }
Ifc2x3::IfcMove::IfcMove(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_TaskId, boost::optional< std::string > v7_Status, boost::optional< std::string > v8_WorkMethod, bool v9_IsMilestone, boost::optional< int > v10_Priority, ::Ifc2x3::IfcSpatialStructureElement* v11_MoveFrom, ::Ifc2x3::IfcSpatialStructureElement* v12_MoveTo, boost::optional< std::vector< std::string > /*[1:?]*/ > v13_PunchList) : IfcTask(IfcEntityInstanceData(in_memory_attribute_storage(13))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (v6_TaskId)); if (v7_Status) {set_attribute_value(6, (*v7_Status)); } if (v8_WorkMethod) {set_attribute_value(7, (*v8_WorkMethod)); }set_attribute_value(8, (v9_IsMilestone)); if (v10_Priority) {set_attribute_value(9, (*v10_Priority)); }set_attribute_value(10, v11_MoveFrom ? v11_MoveFrom->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(11, v12_MoveTo ? v12_MoveTo->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v13_PunchList) {set_attribute_value(12, (*v13_PunchList)); }; populate_derived(); }

// Function implementations for IfcNamedUnit
::Ifc2x3::IfcDimensionalExponents* Ifc2x3::IfcNamedUnit::Dimensions() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcDimensionalExponents>(true); }
void Ifc2x3::IfcNamedUnit::setDimensions(::Ifc2x3::IfcDimensionalExponents* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcUnitEnum::Value Ifc2x3::IfcNamedUnit::UnitType() const {  return ::Ifc2x3::IfcUnitEnum::FromString(get_attribute_value(1)); }
void Ifc2x3::IfcNamedUnit::setUnitType(::Ifc2x3::IfcUnitEnum::Value v) { set_attribute_value(1, EnumerationReference(&::Ifc2x3::IfcUnitEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcNamedUnit::declaration() const { return *((IfcParse::entity*)IFC2X3_types[511]); }
const IfcParse::entity& Ifc2x3::IfcNamedUnit::Class() { return *((IfcParse::entity*)IFC2X3_types[511]); }
Ifc2x3::IfcNamedUnit::IfcNamedUnit(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcNamedUnit::IfcNamedUnit(::Ifc2x3::IfcDimensionalExponents* v1_Dimensions, ::Ifc2x3::IfcUnitEnum::Value v2_UnitType) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_Dimensions ? v1_Dimensions->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (EnumerationReference(&::Ifc2x3::IfcUnitEnum::Class(),(size_t)v2_UnitType)));; populate_derived(); }

// Function implementations for IfcObject
boost::optional< std::string > Ifc2x3::IfcObject::ObjectType() const { if(get_attribute_value(4).isNull()) { return boost::none; } std::string v = get_attribute_value(4); return v; }
void Ifc2x3::IfcObject::setObjectType(boost::optional< std::string > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }

::Ifc2x3::IfcRelDefines::list::ptr Ifc2x3::IfcObject::IsDefinedBy() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[702], 4)->as<IfcRelDefines>(); }

const IfcParse::entity& Ifc2x3::IfcObject::declaration() const { return *((IfcParse::entity*)IFC2X3_types[515]); }
const IfcParse::entity& Ifc2x3::IfcObject::Class() { return *((IfcParse::entity*)IFC2X3_types[515]); }
Ifc2x3::IfcObject::IfcObject(IfcEntityInstanceData&& e) : IfcObjectDefinition(std::move(e)) { }
Ifc2x3::IfcObject::IfcObject(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcObjectDefinition(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }; populate_derived(); }

// Function implementations for IfcObjectDefinition

::Ifc2x3::IfcRelAssigns::list::ptr Ifc2x3::IfcObjectDefinition::HasAssignments() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[668], 4)->as<IfcRelAssigns>(); }
::Ifc2x3::IfcRelDecomposes::list::ptr Ifc2x3::IfcObjectDefinition::IsDecomposedBy() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[701], 4)->as<IfcRelDecomposes>(); }
::Ifc2x3::IfcRelDecomposes::list::ptr Ifc2x3::IfcObjectDefinition::Decomposes() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[701], 5)->as<IfcRelDecomposes>(); }
::Ifc2x3::IfcRelAssociates::list::ptr Ifc2x3::IfcObjectDefinition::HasAssociations() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[677], 4)->as<IfcRelAssociates>(); }

const IfcParse::entity& Ifc2x3::IfcObjectDefinition::declaration() const { return *((IfcParse::entity*)IFC2X3_types[516]); }
const IfcParse::entity& Ifc2x3::IfcObjectDefinition::Class() { return *((IfcParse::entity*)IFC2X3_types[516]); }
Ifc2x3::IfcObjectDefinition::IfcObjectDefinition(IfcEntityInstanceData&& e) : IfcRoot(std::move(e)) { }
Ifc2x3::IfcObjectDefinition::IfcObjectDefinition(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcRoot(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }; populate_derived(); }

// Function implementations for IfcObjectPlacement

::Ifc2x3::IfcProduct::list::ptr Ifc2x3::IfcObjectPlacement::PlacesObject() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[600], 5)->as<IfcProduct>(); }
::Ifc2x3::IfcLocalPlacement::list::ptr Ifc2x3::IfcObjectPlacement::ReferencedByPlacements() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[459], 0)->as<IfcLocalPlacement>(); }

const IfcParse::entity& Ifc2x3::IfcObjectPlacement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[519]); }
const IfcParse::entity& Ifc2x3::IfcObjectPlacement::Class() { return *((IfcParse::entity*)IFC2X3_types[519]); }
Ifc2x3::IfcObjectPlacement::IfcObjectPlacement(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcObjectPlacement::IfcObjectPlacement() : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(0))) { ; populate_derived(); }

// Function implementations for IfcObjective
::Ifc2x3::IfcMetric* Ifc2x3::IfcObjective::BenchmarkValues() const { if(get_attribute_value(7).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(7)))->as<::Ifc2x3::IfcMetric>(true); }
void Ifc2x3::IfcObjective::setBenchmarkValues(::Ifc2x3::IfcMetric* v) { set_attribute_value(7, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(7); }
::Ifc2x3::IfcMetric* Ifc2x3::IfcObjective::ResultValues() const { if(get_attribute_value(8).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(8)))->as<::Ifc2x3::IfcMetric>(true); }
void Ifc2x3::IfcObjective::setResultValues(::Ifc2x3::IfcMetric* v) { set_attribute_value(8, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(8); }
::Ifc2x3::IfcObjectiveEnum::Value Ifc2x3::IfcObjective::ObjectiveQualifier() const {  return ::Ifc2x3::IfcObjectiveEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcObjective::setObjectiveQualifier(::Ifc2x3::IfcObjectiveEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcObjectiveEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
boost::optional< std::string > Ifc2x3::IfcObjective::UserDefinedQualifier() const { if(get_attribute_value(10).isNull()) { return boost::none; } std::string v = get_attribute_value(10); return v; }
void Ifc2x3::IfcObjective::setUserDefinedQualifier(boost::optional< std::string > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }


const IfcParse::entity& Ifc2x3::IfcObjective::declaration() const { return *((IfcParse::entity*)IFC2X3_types[517]); }
const IfcParse::entity& Ifc2x3::IfcObjective::Class() { return *((IfcParse::entity*)IFC2X3_types[517]); }
Ifc2x3::IfcObjective::IfcObjective(IfcEntityInstanceData&& e) : IfcConstraint(std::move(e)) { }
Ifc2x3::IfcObjective::IfcObjective(std::string v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcConstraintEnum::Value v3_ConstraintGrade, boost::optional< std::string > v4_ConstraintSource, ::Ifc2x3::IfcActorSelect* v5_CreatingActor, ::Ifc2x3::IfcDateTimeSelect* v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade, ::Ifc2x3::IfcMetric* v8_BenchmarkValues, ::Ifc2x3::IfcMetric* v9_ResultValues, ::Ifc2x3::IfcObjectiveEnum::Value v10_ObjectiveQualifier, boost::optional< std::string > v11_UserDefinedQualifier) : IfcConstraint(IfcEntityInstanceData(in_memory_attribute_storage(11))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcConstraintEnum::Class(),(size_t)v3_ConstraintGrade))); if (v4_ConstraintSource) {set_attribute_value(3, (*v4_ConstraintSource)); }set_attribute_value(4, v5_CreatingActor ? v5_CreatingActor->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_CreationTime ? v6_CreationTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v7_UserDefinedGrade) {set_attribute_value(6, (*v7_UserDefinedGrade)); }set_attribute_value(7, v8_BenchmarkValues ? v8_BenchmarkValues->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(8, v9_ResultValues ? v9_ResultValues->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcObjectiveEnum::Class(),(size_t)v10_ObjectiveQualifier))); if (v11_UserDefinedQualifier) {set_attribute_value(10, (*v11_UserDefinedQualifier)); }; populate_derived(); }

// Function implementations for IfcOccupant
::Ifc2x3::IfcOccupantTypeEnum::Value Ifc2x3::IfcOccupant::PredefinedType() const {  return ::Ifc2x3::IfcOccupantTypeEnum::FromString(get_attribute_value(6)); }
void Ifc2x3::IfcOccupant::setPredefinedType(::Ifc2x3::IfcOccupantTypeEnum::Value v) { set_attribute_value(6, EnumerationReference(&::Ifc2x3::IfcOccupantTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcOccupant::declaration() const { return *((IfcParse::entity*)IFC2X3_types[522]); }
const IfcParse::entity& Ifc2x3::IfcOccupant::Class() { return *((IfcParse::entity*)IFC2X3_types[522]); }
Ifc2x3::IfcOccupant::IfcOccupant(IfcEntityInstanceData&& e) : IfcActor(std::move(e)) { }
Ifc2x3::IfcOccupant::IfcOccupant(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcActorSelect* v6_TheActor, ::Ifc2x3::IfcOccupantTypeEnum::Value v7_PredefinedType) : IfcActor(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_TheActor ? v6_TheActor->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, (EnumerationReference(&::Ifc2x3::IfcOccupantTypeEnum::Class(),(size_t)v7_PredefinedType)));; populate_derived(); }

// Function implementations for IfcOffsetCurve2D
::Ifc2x3::IfcCurve* Ifc2x3::IfcOffsetCurve2D::BasisCurve() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcCurve>(true); }
void Ifc2x3::IfcOffsetCurve2D::setBasisCurve(::Ifc2x3::IfcCurve* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
double Ifc2x3::IfcOffsetCurve2D::Distance() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcOffsetCurve2D::setDistance(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
boost::logic::tribool Ifc2x3::IfcOffsetCurve2D::SelfIntersect() const {  boost::logic::tribool v = get_attribute_value(2); return v; }
void Ifc2x3::IfcOffsetCurve2D::setSelfIntersect(boost::logic::tribool v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcOffsetCurve2D::declaration() const { return *((IfcParse::entity*)IFC2X3_types[524]); }
const IfcParse::entity& Ifc2x3::IfcOffsetCurve2D::Class() { return *((IfcParse::entity*)IFC2X3_types[524]); }
Ifc2x3::IfcOffsetCurve2D::IfcOffsetCurve2D(IfcEntityInstanceData&& e) : IfcCurve(std::move(e)) { }
Ifc2x3::IfcOffsetCurve2D::IfcOffsetCurve2D(::Ifc2x3::IfcCurve* v1_BasisCurve, double v2_Distance, boost::logic::tribool v3_SelfIntersect) : IfcCurve(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_BasisCurve ? v1_BasisCurve->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Distance));set_attribute_value(2, (v3_SelfIntersect));; populate_derived(); }

// Function implementations for IfcOffsetCurve3D
::Ifc2x3::IfcCurve* Ifc2x3::IfcOffsetCurve3D::BasisCurve() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcCurve>(true); }
void Ifc2x3::IfcOffsetCurve3D::setBasisCurve(::Ifc2x3::IfcCurve* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
double Ifc2x3::IfcOffsetCurve3D::Distance() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcOffsetCurve3D::setDistance(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
boost::logic::tribool Ifc2x3::IfcOffsetCurve3D::SelfIntersect() const {  boost::logic::tribool v = get_attribute_value(2); return v; }
void Ifc2x3::IfcOffsetCurve3D::setSelfIntersect(boost::logic::tribool v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcDirection* Ifc2x3::IfcOffsetCurve3D::RefDirection() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcDirection>(true); }
void Ifc2x3::IfcOffsetCurve3D::setRefDirection(::Ifc2x3::IfcDirection* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcOffsetCurve3D::declaration() const { return *((IfcParse::entity*)IFC2X3_types[525]); }
const IfcParse::entity& Ifc2x3::IfcOffsetCurve3D::Class() { return *((IfcParse::entity*)IFC2X3_types[525]); }
Ifc2x3::IfcOffsetCurve3D::IfcOffsetCurve3D(IfcEntityInstanceData&& e) : IfcCurve(std::move(e)) { }
Ifc2x3::IfcOffsetCurve3D::IfcOffsetCurve3D(::Ifc2x3::IfcCurve* v1_BasisCurve, double v2_Distance, boost::logic::tribool v3_SelfIntersect, ::Ifc2x3::IfcDirection* v4_RefDirection) : IfcCurve(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_BasisCurve ? v1_BasisCurve->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Distance));set_attribute_value(2, (v3_SelfIntersect));set_attribute_value(3, v4_RefDirection ? v4_RefDirection->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcOneDirectionRepeatFactor
::Ifc2x3::IfcVector* Ifc2x3::IfcOneDirectionRepeatFactor::RepeatFactor() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcVector>(true); }
void Ifc2x3::IfcOneDirectionRepeatFactor::setRepeatFactor(::Ifc2x3::IfcVector* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcOneDirectionRepeatFactor::declaration() const { return *((IfcParse::entity*)IFC2X3_types[526]); }
const IfcParse::entity& Ifc2x3::IfcOneDirectionRepeatFactor::Class() { return *((IfcParse::entity*)IFC2X3_types[526]); }
Ifc2x3::IfcOneDirectionRepeatFactor::IfcOneDirectionRepeatFactor(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcOneDirectionRepeatFactor::IfcOneDirectionRepeatFactor(::Ifc2x3::IfcVector* v1_RepeatFactor) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, v1_RepeatFactor ? v1_RepeatFactor->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcOpenShell


const IfcParse::entity& Ifc2x3::IfcOpenShell::declaration() const { return *((IfcParse::entity*)IFC2X3_types[528]); }
const IfcParse::entity& Ifc2x3::IfcOpenShell::Class() { return *((IfcParse::entity*)IFC2X3_types[528]); }
Ifc2x3::IfcOpenShell::IfcOpenShell(IfcEntityInstanceData&& e) : IfcConnectedFaceSet(std::move(e)) { }
Ifc2x3::IfcOpenShell::IfcOpenShell(aggregate_of< ::Ifc2x3::IfcFace >::ptr v1_CfsFaces) : IfcConnectedFaceSet(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_CfsFaces)->generalize());; populate_derived(); }

// Function implementations for IfcOpeningElement

::Ifc2x3::IfcRelFillsElement::list::ptr Ifc2x3::IfcOpeningElement::HasFillings() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[705], 4)->as<IfcRelFillsElement>(); }

const IfcParse::entity& Ifc2x3::IfcOpeningElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[527]); }
const IfcParse::entity& Ifc2x3::IfcOpeningElement::Class() { return *((IfcParse::entity*)IFC2X3_types[527]); }
Ifc2x3::IfcOpeningElement::IfcOpeningElement(IfcEntityInstanceData&& e) : IfcFeatureElementSubtraction(std::move(e)) { }
Ifc2x3::IfcOpeningElement::IfcOpeningElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcFeatureElementSubtraction(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcOpticalMaterialProperties
boost::optional< double > Ifc2x3::IfcOpticalMaterialProperties::VisibleTransmittance() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcOpticalMaterialProperties::setVisibleTransmittance(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcOpticalMaterialProperties::SolarTransmittance() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcOpticalMaterialProperties::setSolarTransmittance(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcOpticalMaterialProperties::ThermalIrTransmittance() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcOpticalMaterialProperties::setThermalIrTransmittance(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< double > Ifc2x3::IfcOpticalMaterialProperties::ThermalIrEmissivityBack() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcOpticalMaterialProperties::setThermalIrEmissivityBack(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< double > Ifc2x3::IfcOpticalMaterialProperties::ThermalIrEmissivityFront() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcOpticalMaterialProperties::setThermalIrEmissivityFront(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< double > Ifc2x3::IfcOpticalMaterialProperties::VisibleReflectanceBack() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcOpticalMaterialProperties::setVisibleReflectanceBack(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
boost::optional< double > Ifc2x3::IfcOpticalMaterialProperties::VisibleReflectanceFront() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcOpticalMaterialProperties::setVisibleReflectanceFront(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
boost::optional< double > Ifc2x3::IfcOpticalMaterialProperties::SolarReflectanceFront() const { if(get_attribute_value(8).isNull()) { return boost::none; } double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcOpticalMaterialProperties::setSolarReflectanceFront(boost::optional< double > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
boost::optional< double > Ifc2x3::IfcOpticalMaterialProperties::SolarReflectanceBack() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcOpticalMaterialProperties::setSolarReflectanceBack(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }


const IfcParse::entity& Ifc2x3::IfcOpticalMaterialProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[529]); }
const IfcParse::entity& Ifc2x3::IfcOpticalMaterialProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[529]); }
Ifc2x3::IfcOpticalMaterialProperties::IfcOpticalMaterialProperties(IfcEntityInstanceData&& e) : IfcMaterialProperties(std::move(e)) { }
Ifc2x3::IfcOpticalMaterialProperties::IfcOpticalMaterialProperties(::Ifc2x3::IfcMaterial* v1_Material, boost::optional< double > v2_VisibleTransmittance, boost::optional< double > v3_SolarTransmittance, boost::optional< double > v4_ThermalIrTransmittance, boost::optional< double > v5_ThermalIrEmissivityBack, boost::optional< double > v6_ThermalIrEmissivityFront, boost::optional< double > v7_VisibleReflectanceBack, boost::optional< double > v8_VisibleReflectanceFront, boost::optional< double > v9_SolarReflectanceFront, boost::optional< double > v10_SolarReflectanceBack) : IfcMaterialProperties(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, v1_Material ? v1_Material->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_VisibleTransmittance) {set_attribute_value(1, (*v2_VisibleTransmittance)); } if (v3_SolarTransmittance) {set_attribute_value(2, (*v3_SolarTransmittance)); } if (v4_ThermalIrTransmittance) {set_attribute_value(3, (*v4_ThermalIrTransmittance)); } if (v5_ThermalIrEmissivityBack) {set_attribute_value(4, (*v5_ThermalIrEmissivityBack)); } if (v6_ThermalIrEmissivityFront) {set_attribute_value(5, (*v6_ThermalIrEmissivityFront)); } if (v7_VisibleReflectanceBack) {set_attribute_value(6, (*v7_VisibleReflectanceBack)); } if (v8_VisibleReflectanceFront) {set_attribute_value(7, (*v8_VisibleReflectanceFront)); } if (v9_SolarReflectanceFront) {set_attribute_value(8, (*v9_SolarReflectanceFront)); } if (v10_SolarReflectanceBack) {set_attribute_value(9, (*v10_SolarReflectanceBack)); }; populate_derived(); }

// Function implementations for IfcOrderAction
std::string Ifc2x3::IfcOrderAction::ActionID() const {  std::string v = get_attribute_value(10); return v; }
void Ifc2x3::IfcOrderAction::setActionID(std::string v) { set_attribute_value(10, v);if constexpr (false)unset_attribute_value(10); }


const IfcParse::entity& Ifc2x3::IfcOrderAction::declaration() const { return *((IfcParse::entity*)IFC2X3_types[530]); }
const IfcParse::entity& Ifc2x3::IfcOrderAction::Class() { return *((IfcParse::entity*)IFC2X3_types[530]); }
Ifc2x3::IfcOrderAction::IfcOrderAction(IfcEntityInstanceData&& e) : IfcTask(std::move(e)) { }
Ifc2x3::IfcOrderAction::IfcOrderAction(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_TaskId, boost::optional< std::string > v7_Status, boost::optional< std::string > v8_WorkMethod, bool v9_IsMilestone, boost::optional< int > v10_Priority, std::string v11_ActionID) : IfcTask(IfcEntityInstanceData(in_memory_attribute_storage(11))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (v6_TaskId)); if (v7_Status) {set_attribute_value(6, (*v7_Status)); } if (v8_WorkMethod) {set_attribute_value(7, (*v8_WorkMethod)); }set_attribute_value(8, (v9_IsMilestone)); if (v10_Priority) {set_attribute_value(9, (*v10_Priority)); }set_attribute_value(10, (v11_ActionID));; populate_derived(); }

// Function implementations for IfcOrganization
boost::optional< std::string > Ifc2x3::IfcOrganization::Id() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcOrganization::setId(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
std::string Ifc2x3::IfcOrganization::Name() const {  std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcOrganization::setName(std::string v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
boost::optional< std::string > Ifc2x3::IfcOrganization::Description() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcOrganization::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< aggregate_of< ::Ifc2x3::IfcActorRole >::ptr > Ifc2x3::IfcOrganization::Roles() const { if(get_attribute_value(3).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(3); return es->as< ::Ifc2x3::IfcActorRole >(); }
void Ifc2x3::IfcOrganization::setRoles(boost::optional< aggregate_of< ::Ifc2x3::IfcActorRole >::ptr > v) { if (v) {set_attribute_value(3, (*v)->generalize());} else {unset_attribute_value(3);} }
boost::optional< aggregate_of< ::Ifc2x3::IfcAddress >::ptr > Ifc2x3::IfcOrganization::Addresses() const { if(get_attribute_value(4).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(4); return es->as< ::Ifc2x3::IfcAddress >(); }
void Ifc2x3::IfcOrganization::setAddresses(boost::optional< aggregate_of< ::Ifc2x3::IfcAddress >::ptr > v) { if (v) {set_attribute_value(4, (*v)->generalize());} else {unset_attribute_value(4);} }

::Ifc2x3::IfcOrganizationRelationship::list::ptr Ifc2x3::IfcOrganization::IsRelatedBy() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[532], 3)->as<IfcOrganizationRelationship>(); }
::Ifc2x3::IfcOrganizationRelationship::list::ptr Ifc2x3::IfcOrganization::Relates() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[532], 2)->as<IfcOrganizationRelationship>(); }
::Ifc2x3::IfcPersonAndOrganization::list::ptr Ifc2x3::IfcOrganization::Engages() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[546], 1)->as<IfcPersonAndOrganization>(); }

const IfcParse::entity& Ifc2x3::IfcOrganization::declaration() const { return *((IfcParse::entity*)IFC2X3_types[531]); }
const IfcParse::entity& Ifc2x3::IfcOrganization::Class() { return *((IfcParse::entity*)IFC2X3_types[531]); }
Ifc2x3::IfcOrganization::IfcOrganization(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcOrganization::IfcOrganization(boost::optional< std::string > v1_Id, std::string v2_Name, boost::optional< std::string > v3_Description, boost::optional< aggregate_of< ::Ifc2x3::IfcActorRole >::ptr > v4_Roles, boost::optional< aggregate_of< ::Ifc2x3::IfcAddress >::ptr > v5_Addresses) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(5))) {  if (v1_Id) {set_attribute_value(0, (*v1_Id)); }set_attribute_value(1, (v2_Name)); if (v3_Description) {set_attribute_value(2, (*v3_Description)); } if (v4_Roles) {set_attribute_value(3, (*v4_Roles)->generalize()); } if (v5_Addresses) {set_attribute_value(4, (*v5_Addresses)->generalize()); }; populate_derived(); }

// Function implementations for IfcOrganizationRelationship
std::string Ifc2x3::IfcOrganizationRelationship::Name() const {  std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcOrganizationRelationship::setName(std::string v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
boost::optional< std::string > Ifc2x3::IfcOrganizationRelationship::Description() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcOrganizationRelationship::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
::Ifc2x3::IfcOrganization* Ifc2x3::IfcOrganizationRelationship::RelatingOrganization() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcOrganization>(true); }
void Ifc2x3::IfcOrganizationRelationship::setRelatingOrganization(::Ifc2x3::IfcOrganization* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
aggregate_of< ::Ifc2x3::IfcOrganization >::ptr Ifc2x3::IfcOrganizationRelationship::RelatedOrganizations() const {  aggregate_of_instance::ptr es = get_attribute_value(3); return es->as< ::Ifc2x3::IfcOrganization >(); }
void Ifc2x3::IfcOrganizationRelationship::setRelatedOrganizations(aggregate_of< ::Ifc2x3::IfcOrganization >::ptr v) { set_attribute_value(3, (v)->generalize());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcOrganizationRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[532]); }
const IfcParse::entity& Ifc2x3::IfcOrganizationRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[532]); }
Ifc2x3::IfcOrganizationRelationship::IfcOrganizationRelationship(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcOrganizationRelationship::IfcOrganizationRelationship(std::string v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcOrganization* v3_RelatingOrganization, aggregate_of< ::Ifc2x3::IfcOrganization >::ptr v4_RelatedOrganizations) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_RelatingOrganization ? v3_RelatingOrganization->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_RelatedOrganizations)->generalize());; populate_derived(); }

// Function implementations for IfcOrientedEdge
::Ifc2x3::IfcEdge* Ifc2x3::IfcOrientedEdge::EdgeElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcEdge>(true); }
void Ifc2x3::IfcOrientedEdge::setEdgeElement(::Ifc2x3::IfcEdge* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
bool Ifc2x3::IfcOrientedEdge::Orientation() const {  bool v = get_attribute_value(3); return v; }
void Ifc2x3::IfcOrientedEdge::setOrientation(bool v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcOrientedEdge::declaration() const { return *((IfcParse::entity*)IFC2X3_types[534]); }
const IfcParse::entity& Ifc2x3::IfcOrientedEdge::Class() { return *((IfcParse::entity*)IFC2X3_types[534]); }
Ifc2x3::IfcOrientedEdge::IfcOrientedEdge(IfcEntityInstanceData&& e) : IfcEdge(std::move(e)) { }
Ifc2x3::IfcOrientedEdge::IfcOrientedEdge(::Ifc2x3::IfcEdge* v3_EdgeElement, bool v4_Orientation) : IfcEdge(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(2, v3_EdgeElement ? v3_EdgeElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_Orientation));; populate_derived(); }

// Function implementations for IfcOutletType
::Ifc2x3::IfcOutletTypeEnum::Value Ifc2x3::IfcOutletType::PredefinedType() const {  return ::Ifc2x3::IfcOutletTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcOutletType::setPredefinedType(::Ifc2x3::IfcOutletTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcOutletTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcOutletType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[535]); }
const IfcParse::entity& Ifc2x3::IfcOutletType::Class() { return *((IfcParse::entity*)IFC2X3_types[535]); }
Ifc2x3::IfcOutletType::IfcOutletType(IfcEntityInstanceData&& e) : IfcFlowTerminalType(std::move(e)) { }
Ifc2x3::IfcOutletType::IfcOutletType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcOutletTypeEnum::Value v10_PredefinedType) : IfcFlowTerminalType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcOutletTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcOwnerHistory
::Ifc2x3::IfcPersonAndOrganization* Ifc2x3::IfcOwnerHistory::OwningUser() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcPersonAndOrganization>(true); }
void Ifc2x3::IfcOwnerHistory::setOwningUser(::Ifc2x3::IfcPersonAndOrganization* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcApplication* Ifc2x3::IfcOwnerHistory::OwningApplication() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcApplication>(true); }
void Ifc2x3::IfcOwnerHistory::setOwningApplication(::Ifc2x3::IfcApplication* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
boost::optional< ::Ifc2x3::IfcStateEnum::Value > Ifc2x3::IfcOwnerHistory::State() const { if(get_attribute_value(2).isNull()) { return boost::none; } return ::Ifc2x3::IfcStateEnum::FromString(get_attribute_value(2)); }
void Ifc2x3::IfcOwnerHistory::setState(boost::optional< ::Ifc2x3::IfcStateEnum::Value > v) { if (v) {set_attribute_value(2, EnumerationReference(&::Ifc2x3::IfcStateEnum::Class(), (size_t) *v));} else {unset_attribute_value(2);} }
::Ifc2x3::IfcChangeActionEnum::Value Ifc2x3::IfcOwnerHistory::ChangeAction() const {  return ::Ifc2x3::IfcChangeActionEnum::FromString(get_attribute_value(3)); }
void Ifc2x3::IfcOwnerHistory::setChangeAction(::Ifc2x3::IfcChangeActionEnum::Value v) { set_attribute_value(3, EnumerationReference(&::Ifc2x3::IfcChangeActionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(3); }
boost::optional< int > Ifc2x3::IfcOwnerHistory::LastModifiedDate() const { if(get_attribute_value(4).isNull()) { return boost::none; } int v = get_attribute_value(4); return v; }
void Ifc2x3::IfcOwnerHistory::setLastModifiedDate(boost::optional< int > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
::Ifc2x3::IfcPersonAndOrganization* Ifc2x3::IfcOwnerHistory::LastModifyingUser() const { if(get_attribute_value(5).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcPersonAndOrganization>(true); }
void Ifc2x3::IfcOwnerHistory::setLastModifyingUser(::Ifc2x3::IfcPersonAndOrganization* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcApplication* Ifc2x3::IfcOwnerHistory::LastModifyingApplication() const { if(get_attribute_value(6).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcApplication>(true); }
void Ifc2x3::IfcOwnerHistory::setLastModifyingApplication(::Ifc2x3::IfcApplication* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
int Ifc2x3::IfcOwnerHistory::CreationDate() const {  int v = get_attribute_value(7); return v; }
void Ifc2x3::IfcOwnerHistory::setCreationDate(int v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }


const IfcParse::entity& Ifc2x3::IfcOwnerHistory::declaration() const { return *((IfcParse::entity*)IFC2X3_types[537]); }
const IfcParse::entity& Ifc2x3::IfcOwnerHistory::Class() { return *((IfcParse::entity*)IFC2X3_types[537]); }
Ifc2x3::IfcOwnerHistory::IfcOwnerHistory(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcOwnerHistory::IfcOwnerHistory(::Ifc2x3::IfcPersonAndOrganization* v1_OwningUser, ::Ifc2x3::IfcApplication* v2_OwningApplication, boost::optional< ::Ifc2x3::IfcStateEnum::Value > v3_State, ::Ifc2x3::IfcChangeActionEnum::Value v4_ChangeAction, boost::optional< int > v5_LastModifiedDate, ::Ifc2x3::IfcPersonAndOrganization* v6_LastModifyingUser, ::Ifc2x3::IfcApplication* v7_LastModifyingApplication, int v8_CreationDate) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, v1_OwningUser ? v1_OwningUser->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_OwningApplication ? v2_OwningApplication->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_State) {set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcStateEnum::Class(),(size_t)*v3_State))); }set_attribute_value(3, (EnumerationReference(&::Ifc2x3::IfcChangeActionEnum::Class(),(size_t)v4_ChangeAction))); if (v5_LastModifiedDate) {set_attribute_value(4, (*v5_LastModifiedDate)); }set_attribute_value(5, v6_LastModifyingUser ? v6_LastModifyingUser->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_LastModifyingApplication ? v7_LastModifyingApplication->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, (v8_CreationDate));; populate_derived(); }

// Function implementations for IfcParameterizedProfileDef
::Ifc2x3::IfcAxis2Placement2D* Ifc2x3::IfcParameterizedProfileDef::Position() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcAxis2Placement2D>(true); }
void Ifc2x3::IfcParameterizedProfileDef::setPosition(::Ifc2x3::IfcAxis2Placement2D* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcParameterizedProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[538]); }
const IfcParse::entity& Ifc2x3::IfcParameterizedProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[538]); }
Ifc2x3::IfcParameterizedProfileDef::IfcParameterizedProfileDef(IfcEntityInstanceData&& e) : IfcProfileDef(std::move(e)) { }
Ifc2x3::IfcParameterizedProfileDef::IfcParameterizedProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcAxis2Placement2D* v3_Position) : IfcProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcPath
aggregate_of< ::Ifc2x3::IfcOrientedEdge >::ptr Ifc2x3::IfcPath::EdgeList() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcOrientedEdge >(); }
void Ifc2x3::IfcPath::setEdgeList(aggregate_of< ::Ifc2x3::IfcOrientedEdge >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcPath::declaration() const { return *((IfcParse::entity*)IFC2X3_types[540]); }
const IfcParse::entity& Ifc2x3::IfcPath::Class() { return *((IfcParse::entity*)IFC2X3_types[540]); }
Ifc2x3::IfcPath::IfcPath(IfcEntityInstanceData&& e) : IfcTopologicalRepresentationItem(std::move(e)) { }
Ifc2x3::IfcPath::IfcPath(aggregate_of< ::Ifc2x3::IfcOrientedEdge >::ptr v1_EdgeList) : IfcTopologicalRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_EdgeList)->generalize());; populate_derived(); }

// Function implementations for IfcPerformanceHistory
std::string Ifc2x3::IfcPerformanceHistory::LifeCyclePhase() const {  std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcPerformanceHistory::setLifeCyclePhase(std::string v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcPerformanceHistory::declaration() const { return *((IfcParse::entity*)IFC2X3_types[541]); }
const IfcParse::entity& Ifc2x3::IfcPerformanceHistory::Class() { return *((IfcParse::entity*)IFC2X3_types[541]); }
Ifc2x3::IfcPerformanceHistory::IfcPerformanceHistory(IfcEntityInstanceData&& e) : IfcControl(std::move(e)) { }
Ifc2x3::IfcPerformanceHistory::IfcPerformanceHistory(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_LifeCyclePhase) : IfcControl(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (v6_LifeCyclePhase));; populate_derived(); }

// Function implementations for IfcPermeableCoveringProperties
::Ifc2x3::IfcPermeableCoveringOperationEnum::Value Ifc2x3::IfcPermeableCoveringProperties::OperationType() const {  return ::Ifc2x3::IfcPermeableCoveringOperationEnum::FromString(get_attribute_value(4)); }
void Ifc2x3::IfcPermeableCoveringProperties::setOperationType(::Ifc2x3::IfcPermeableCoveringOperationEnum::Value v) { set_attribute_value(4, EnumerationReference(&::Ifc2x3::IfcPermeableCoveringOperationEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcWindowPanelPositionEnum::Value Ifc2x3::IfcPermeableCoveringProperties::PanelPosition() const {  return ::Ifc2x3::IfcWindowPanelPositionEnum::FromString(get_attribute_value(5)); }
void Ifc2x3::IfcPermeableCoveringProperties::setPanelPosition(::Ifc2x3::IfcWindowPanelPositionEnum::Value v) { set_attribute_value(5, EnumerationReference(&::Ifc2x3::IfcWindowPanelPositionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(5); }
boost::optional< double > Ifc2x3::IfcPermeableCoveringProperties::FrameDepth() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcPermeableCoveringProperties::setFrameDepth(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
boost::optional< double > Ifc2x3::IfcPermeableCoveringProperties::FrameThickness() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcPermeableCoveringProperties::setFrameThickness(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
::Ifc2x3::IfcShapeAspect* Ifc2x3::IfcPermeableCoveringProperties::ShapeAspectStyle() const { if(get_attribute_value(8).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(8)))->as<::Ifc2x3::IfcShapeAspect>(true); }
void Ifc2x3::IfcPermeableCoveringProperties::setShapeAspectStyle(::Ifc2x3::IfcShapeAspect* v) { set_attribute_value(8, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(8); }


const IfcParse::entity& Ifc2x3::IfcPermeableCoveringProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[543]); }
const IfcParse::entity& Ifc2x3::IfcPermeableCoveringProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[543]); }
Ifc2x3::IfcPermeableCoveringProperties::IfcPermeableCoveringProperties(IfcEntityInstanceData&& e) : IfcPropertySetDefinition(std::move(e)) { }
Ifc2x3::IfcPermeableCoveringProperties::IfcPermeableCoveringProperties(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcPermeableCoveringOperationEnum::Value v5_OperationType, ::Ifc2x3::IfcWindowPanelPositionEnum::Value v6_PanelPosition, boost::optional< double > v7_FrameDepth, boost::optional< double > v8_FrameThickness, ::Ifc2x3::IfcShapeAspect* v9_ShapeAspectStyle) : IfcPropertySetDefinition(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (EnumerationReference(&::Ifc2x3::IfcPermeableCoveringOperationEnum::Class(),(size_t)v5_OperationType)));set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcWindowPanelPositionEnum::Class(),(size_t)v6_PanelPosition))); if (v7_FrameDepth) {set_attribute_value(6, (*v7_FrameDepth)); } if (v8_FrameThickness) {set_attribute_value(7, (*v8_FrameThickness)); }set_attribute_value(8, v9_ShapeAspectStyle ? v9_ShapeAspectStyle->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcPermit
std::string Ifc2x3::IfcPermit::PermitID() const {  std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcPermit::setPermitID(std::string v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcPermit::declaration() const { return *((IfcParse::entity*)IFC2X3_types[544]); }
const IfcParse::entity& Ifc2x3::IfcPermit::Class() { return *((IfcParse::entity*)IFC2X3_types[544]); }
Ifc2x3::IfcPermit::IfcPermit(IfcEntityInstanceData&& e) : IfcControl(std::move(e)) { }
Ifc2x3::IfcPermit::IfcPermit(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_PermitID) : IfcControl(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (v6_PermitID));; populate_derived(); }

// Function implementations for IfcPerson
boost::optional< std::string > Ifc2x3::IfcPerson::Id() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcPerson::setId(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
boost::optional< std::string > Ifc2x3::IfcPerson::FamilyName() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcPerson::setFamilyName(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< std::string > Ifc2x3::IfcPerson::GivenName() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcPerson::setGivenName(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< std::vector< std::string > /*[1:?]*/ > Ifc2x3::IfcPerson::MiddleNames() const { if(get_attribute_value(3).isNull()) { return boost::none; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(3); return v; }
void Ifc2x3::IfcPerson::setMiddleNames(boost::optional< std::vector< std::string > /*[1:?]*/ > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< std::vector< std::string > /*[1:?]*/ > Ifc2x3::IfcPerson::PrefixTitles() const { if(get_attribute_value(4).isNull()) { return boost::none; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(4); return v; }
void Ifc2x3::IfcPerson::setPrefixTitles(boost::optional< std::vector< std::string > /*[1:?]*/ > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< std::vector< std::string > /*[1:?]*/ > Ifc2x3::IfcPerson::SuffixTitles() const { if(get_attribute_value(5).isNull()) { return boost::none; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(5); return v; }
void Ifc2x3::IfcPerson::setSuffixTitles(boost::optional< std::vector< std::string > /*[1:?]*/ > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< aggregate_of< ::Ifc2x3::IfcActorRole >::ptr > Ifc2x3::IfcPerson::Roles() const { if(get_attribute_value(6).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(6); return es->as< ::Ifc2x3::IfcActorRole >(); }
void Ifc2x3::IfcPerson::setRoles(boost::optional< aggregate_of< ::Ifc2x3::IfcActorRole >::ptr > v) { if (v) {set_attribute_value(6, (*v)->generalize());} else {unset_attribute_value(6);} }
boost::optional< aggregate_of< ::Ifc2x3::IfcAddress >::ptr > Ifc2x3::IfcPerson::Addresses() const { if(get_attribute_value(7).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(7); return es->as< ::Ifc2x3::IfcAddress >(); }
void Ifc2x3::IfcPerson::setAddresses(boost::optional< aggregate_of< ::Ifc2x3::IfcAddress >::ptr > v) { if (v) {set_attribute_value(7, (*v)->generalize());} else {unset_attribute_value(7);} }

::Ifc2x3::IfcPersonAndOrganization::list::ptr Ifc2x3::IfcPerson::EngagedIn() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[546], 0)->as<IfcPersonAndOrganization>(); }

const IfcParse::entity& Ifc2x3::IfcPerson::declaration() const { return *((IfcParse::entity*)IFC2X3_types[545]); }
const IfcParse::entity& Ifc2x3::IfcPerson::Class() { return *((IfcParse::entity*)IFC2X3_types[545]); }
Ifc2x3::IfcPerson::IfcPerson(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcPerson::IfcPerson(boost::optional< std::string > v1_Id, boost::optional< std::string > v2_FamilyName, boost::optional< std::string > v3_GivenName, boost::optional< std::vector< std::string > /*[1:?]*/ > v4_MiddleNames, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_PrefixTitles, boost::optional< std::vector< std::string > /*[1:?]*/ > v6_SuffixTitles, boost::optional< aggregate_of< ::Ifc2x3::IfcActorRole >::ptr > v7_Roles, boost::optional< aggregate_of< ::Ifc2x3::IfcAddress >::ptr > v8_Addresses) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(8))) {  if (v1_Id) {set_attribute_value(0, (*v1_Id)); } if (v2_FamilyName) {set_attribute_value(1, (*v2_FamilyName)); } if (v3_GivenName) {set_attribute_value(2, (*v3_GivenName)); } if (v4_MiddleNames) {set_attribute_value(3, (*v4_MiddleNames)); } if (v5_PrefixTitles) {set_attribute_value(4, (*v5_PrefixTitles)); } if (v6_SuffixTitles) {set_attribute_value(5, (*v6_SuffixTitles)); } if (v7_Roles) {set_attribute_value(6, (*v7_Roles)->generalize()); } if (v8_Addresses) {set_attribute_value(7, (*v8_Addresses)->generalize()); }; populate_derived(); }

// Function implementations for IfcPersonAndOrganization
::Ifc2x3::IfcPerson* Ifc2x3::IfcPersonAndOrganization::ThePerson() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcPerson>(true); }
void Ifc2x3::IfcPersonAndOrganization::setThePerson(::Ifc2x3::IfcPerson* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcOrganization* Ifc2x3::IfcPersonAndOrganization::TheOrganization() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcOrganization>(true); }
void Ifc2x3::IfcPersonAndOrganization::setTheOrganization(::Ifc2x3::IfcOrganization* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
boost::optional< aggregate_of< ::Ifc2x3::IfcActorRole >::ptr > Ifc2x3::IfcPersonAndOrganization::Roles() const { if(get_attribute_value(2).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(2); return es->as< ::Ifc2x3::IfcActorRole >(); }
void Ifc2x3::IfcPersonAndOrganization::setRoles(boost::optional< aggregate_of< ::Ifc2x3::IfcActorRole >::ptr > v) { if (v) {set_attribute_value(2, (*v)->generalize());} else {unset_attribute_value(2);} }


const IfcParse::entity& Ifc2x3::IfcPersonAndOrganization::declaration() const { return *((IfcParse::entity*)IFC2X3_types[546]); }
const IfcParse::entity& Ifc2x3::IfcPersonAndOrganization::Class() { return *((IfcParse::entity*)IFC2X3_types[546]); }
Ifc2x3::IfcPersonAndOrganization::IfcPersonAndOrganization(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcPersonAndOrganization::IfcPersonAndOrganization(::Ifc2x3::IfcPerson* v1_ThePerson, ::Ifc2x3::IfcOrganization* v2_TheOrganization, boost::optional< aggregate_of< ::Ifc2x3::IfcActorRole >::ptr > v3_Roles) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_ThePerson ? v1_ThePerson->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_TheOrganization ? v2_TheOrganization->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Roles) {set_attribute_value(2, (*v3_Roles)->generalize()); }; populate_derived(); }

// Function implementations for IfcPhysicalComplexQuantity
aggregate_of< ::Ifc2x3::IfcPhysicalQuantity >::ptr Ifc2x3::IfcPhysicalComplexQuantity::HasQuantities() const {  aggregate_of_instance::ptr es = get_attribute_value(2); return es->as< ::Ifc2x3::IfcPhysicalQuantity >(); }
void Ifc2x3::IfcPhysicalComplexQuantity::setHasQuantities(aggregate_of< ::Ifc2x3::IfcPhysicalQuantity >::ptr v) { set_attribute_value(2, (v)->generalize());if constexpr (false)unset_attribute_value(2); }
std::string Ifc2x3::IfcPhysicalComplexQuantity::Discrimination() const {  std::string v = get_attribute_value(3); return v; }
void Ifc2x3::IfcPhysicalComplexQuantity::setDiscrimination(std::string v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
boost::optional< std::string > Ifc2x3::IfcPhysicalComplexQuantity::Quality() const { if(get_attribute_value(4).isNull()) { return boost::none; } std::string v = get_attribute_value(4); return v; }
void Ifc2x3::IfcPhysicalComplexQuantity::setQuality(boost::optional< std::string > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< std::string > Ifc2x3::IfcPhysicalComplexQuantity::Usage() const { if(get_attribute_value(5).isNull()) { return boost::none; } std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcPhysicalComplexQuantity::setUsage(boost::optional< std::string > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }


const IfcParse::entity& Ifc2x3::IfcPhysicalComplexQuantity::declaration() const { return *((IfcParse::entity*)IFC2X3_types[548]); }
const IfcParse::entity& Ifc2x3::IfcPhysicalComplexQuantity::Class() { return *((IfcParse::entity*)IFC2X3_types[548]); }
Ifc2x3::IfcPhysicalComplexQuantity::IfcPhysicalComplexQuantity(IfcEntityInstanceData&& e) : IfcPhysicalQuantity(std::move(e)) { }
Ifc2x3::IfcPhysicalComplexQuantity::IfcPhysicalComplexQuantity(std::string v1_Name, boost::optional< std::string > v2_Description, aggregate_of< ::Ifc2x3::IfcPhysicalQuantity >::ptr v3_HasQuantities, std::string v4_Discrimination, boost::optional< std::string > v5_Quality, boost::optional< std::string > v6_Usage) : IfcPhysicalQuantity(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_HasQuantities)->generalize());set_attribute_value(3, (v4_Discrimination)); if (v5_Quality) {set_attribute_value(4, (*v5_Quality)); } if (v6_Usage) {set_attribute_value(5, (*v6_Usage)); }; populate_derived(); }

// Function implementations for IfcPhysicalQuantity
std::string Ifc2x3::IfcPhysicalQuantity::Name() const {  std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcPhysicalQuantity::setName(std::string v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
boost::optional< std::string > Ifc2x3::IfcPhysicalQuantity::Description() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcPhysicalQuantity::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }

::Ifc2x3::IfcPhysicalComplexQuantity::list::ptr Ifc2x3::IfcPhysicalQuantity::PartOfComplex() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[548], 2)->as<IfcPhysicalComplexQuantity>(); }

const IfcParse::entity& Ifc2x3::IfcPhysicalQuantity::declaration() const { return *((IfcParse::entity*)IFC2X3_types[550]); }
const IfcParse::entity& Ifc2x3::IfcPhysicalQuantity::Class() { return *((IfcParse::entity*)IFC2X3_types[550]); }
Ifc2x3::IfcPhysicalQuantity::IfcPhysicalQuantity(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcPhysicalQuantity::IfcPhysicalQuantity(std::string v1_Name, boost::optional< std::string > v2_Description) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }; populate_derived(); }

// Function implementations for IfcPhysicalSimpleQuantity
::Ifc2x3::IfcNamedUnit* Ifc2x3::IfcPhysicalSimpleQuantity::Unit() const { if(get_attribute_value(2).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcNamedUnit>(true); }
void Ifc2x3::IfcPhysicalSimpleQuantity::setUnit(::Ifc2x3::IfcNamedUnit* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcPhysicalSimpleQuantity::declaration() const { return *((IfcParse::entity*)IFC2X3_types[551]); }
const IfcParse::entity& Ifc2x3::IfcPhysicalSimpleQuantity::Class() { return *((IfcParse::entity*)IFC2X3_types[551]); }
Ifc2x3::IfcPhysicalSimpleQuantity::IfcPhysicalSimpleQuantity(IfcEntityInstanceData&& e) : IfcPhysicalQuantity(std::move(e)) { }
Ifc2x3::IfcPhysicalSimpleQuantity::IfcPhysicalSimpleQuantity(std::string v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcNamedUnit* v3_Unit) : IfcPhysicalQuantity(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_Unit ? v3_Unit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcPile
::Ifc2x3::IfcPileTypeEnum::Value Ifc2x3::IfcPile::PredefinedType() const {  return ::Ifc2x3::IfcPileTypeEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcPile::setPredefinedType(::Ifc2x3::IfcPileTypeEnum::Value v) { set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcPileTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }
boost::optional< ::Ifc2x3::IfcPileConstructionEnum::Value > Ifc2x3::IfcPile::ConstructionType() const { if(get_attribute_value(9).isNull()) { return boost::none; } return ::Ifc2x3::IfcPileConstructionEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcPile::setConstructionType(boost::optional< ::Ifc2x3::IfcPileConstructionEnum::Value > v) { if (v) {set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcPileConstructionEnum::Class(), (size_t) *v));} else {unset_attribute_value(9);} }


const IfcParse::entity& Ifc2x3::IfcPile::declaration() const { return *((IfcParse::entity*)IFC2X3_types[552]); }
const IfcParse::entity& Ifc2x3::IfcPile::Class() { return *((IfcParse::entity*)IFC2X3_types[552]); }
Ifc2x3::IfcPile::IfcPile(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcPile::IfcPile(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, ::Ifc2x3::IfcPileTypeEnum::Value v9_PredefinedType, boost::optional< ::Ifc2x3::IfcPileConstructionEnum::Value > v10_ConstructionType) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcPileTypeEnum::Class(),(size_t)v9_PredefinedType))); if (v10_ConstructionType) {set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcPileConstructionEnum::Class(),(size_t)*v10_ConstructionType))); }; populate_derived(); }

// Function implementations for IfcPipeFittingType
::Ifc2x3::IfcPipeFittingTypeEnum::Value Ifc2x3::IfcPipeFittingType::PredefinedType() const {  return ::Ifc2x3::IfcPipeFittingTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcPipeFittingType::setPredefinedType(::Ifc2x3::IfcPipeFittingTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcPipeFittingTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcPipeFittingType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[555]); }
const IfcParse::entity& Ifc2x3::IfcPipeFittingType::Class() { return *((IfcParse::entity*)IFC2X3_types[555]); }
Ifc2x3::IfcPipeFittingType::IfcPipeFittingType(IfcEntityInstanceData&& e) : IfcFlowFittingType(std::move(e)) { }
Ifc2x3::IfcPipeFittingType::IfcPipeFittingType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcPipeFittingTypeEnum::Value v10_PredefinedType) : IfcFlowFittingType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcPipeFittingTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcPipeSegmentType
::Ifc2x3::IfcPipeSegmentTypeEnum::Value Ifc2x3::IfcPipeSegmentType::PredefinedType() const {  return ::Ifc2x3::IfcPipeSegmentTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcPipeSegmentType::setPredefinedType(::Ifc2x3::IfcPipeSegmentTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcPipeSegmentTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcPipeSegmentType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[557]); }
const IfcParse::entity& Ifc2x3::IfcPipeSegmentType::Class() { return *((IfcParse::entity*)IFC2X3_types[557]); }
Ifc2x3::IfcPipeSegmentType::IfcPipeSegmentType(IfcEntityInstanceData&& e) : IfcFlowSegmentType(std::move(e)) { }
Ifc2x3::IfcPipeSegmentType::IfcPipeSegmentType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcPipeSegmentTypeEnum::Value v10_PredefinedType) : IfcFlowSegmentType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcPipeSegmentTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcPixelTexture
int Ifc2x3::IfcPixelTexture::Width() const {  int v = get_attribute_value(4); return v; }
void Ifc2x3::IfcPixelTexture::setWidth(int v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
int Ifc2x3::IfcPixelTexture::Height() const {  int v = get_attribute_value(5); return v; }
void Ifc2x3::IfcPixelTexture::setHeight(int v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
int Ifc2x3::IfcPixelTexture::ColourComponents() const {  int v = get_attribute_value(6); return v; }
void Ifc2x3::IfcPixelTexture::setColourComponents(int v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
std::vector< boost::dynamic_bitset<> > /*[1:?]*/ Ifc2x3::IfcPixelTexture::Pixel() const {  std::vector< boost::dynamic_bitset<> > /*[1:?]*/ v = get_attribute_value(7); return v; }
void Ifc2x3::IfcPixelTexture::setPixel(std::vector< boost::dynamic_bitset<> > /*[1:?]*/ v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }


const IfcParse::entity& Ifc2x3::IfcPixelTexture::declaration() const { return *((IfcParse::entity*)IFC2X3_types[559]); }
const IfcParse::entity& Ifc2x3::IfcPixelTexture::Class() { return *((IfcParse::entity*)IFC2X3_types[559]); }
Ifc2x3::IfcPixelTexture::IfcPixelTexture(IfcEntityInstanceData&& e) : IfcSurfaceTexture(std::move(e)) { }
Ifc2x3::IfcPixelTexture::IfcPixelTexture(bool v1_RepeatS, bool v2_RepeatT, ::Ifc2x3::IfcSurfaceTextureEnum::Value v3_TextureType, ::Ifc2x3::IfcCartesianTransformationOperator2D* v4_TextureTransform, int v5_Width, int v6_Height, int v7_ColourComponents, std::vector< boost::dynamic_bitset<> > /*[1:?]*/ v8_Pixel) : IfcSurfaceTexture(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_RepeatS));set_attribute_value(1, (v2_RepeatT));set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcSurfaceTextureEnum::Class(),(size_t)v3_TextureType)));set_attribute_value(3, v4_TextureTransform ? v4_TextureTransform->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(4, (v5_Width));set_attribute_value(5, (v6_Height));set_attribute_value(6, (v7_ColourComponents));set_attribute_value(7, (v8_Pixel));; populate_derived(); }

// Function implementations for IfcPlacement
::Ifc2x3::IfcCartesianPoint* Ifc2x3::IfcPlacement::Location() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcCartesianPoint>(true); }
void Ifc2x3::IfcPlacement::setLocation(::Ifc2x3::IfcCartesianPoint* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcPlacement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[560]); }
const IfcParse::entity& Ifc2x3::IfcPlacement::Class() { return *((IfcParse::entity*)IFC2X3_types[560]); }
Ifc2x3::IfcPlacement::IfcPlacement(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcPlacement::IfcPlacement(::Ifc2x3::IfcCartesianPoint* v1_Location) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, v1_Location ? v1_Location->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcPlanarBox
::Ifc2x3::IfcAxis2Placement* Ifc2x3::IfcPlanarBox::Placement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcAxis2Placement>(true); }
void Ifc2x3::IfcPlanarBox::setPlacement(::Ifc2x3::IfcAxis2Placement* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcPlanarBox::declaration() const { return *((IfcParse::entity*)IFC2X3_types[561]); }
const IfcParse::entity& Ifc2x3::IfcPlanarBox::Class() { return *((IfcParse::entity*)IFC2X3_types[561]); }
Ifc2x3::IfcPlanarBox::IfcPlanarBox(IfcEntityInstanceData&& e) : IfcPlanarExtent(std::move(e)) { }
Ifc2x3::IfcPlanarBox::IfcPlanarBox(double v1_SizeInX, double v2_SizeInY, ::Ifc2x3::IfcAxis2Placement* v3_Placement) : IfcPlanarExtent(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, (v1_SizeInX));set_attribute_value(1, (v2_SizeInY));set_attribute_value(2, v3_Placement ? v3_Placement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcPlanarExtent
double Ifc2x3::IfcPlanarExtent::SizeInX() const {  double v = get_attribute_value(0); return v; }
void Ifc2x3::IfcPlanarExtent::setSizeInX(double v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
double Ifc2x3::IfcPlanarExtent::SizeInY() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcPlanarExtent::setSizeInY(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcPlanarExtent::declaration() const { return *((IfcParse::entity*)IFC2X3_types[562]); }
const IfcParse::entity& Ifc2x3::IfcPlanarExtent::Class() { return *((IfcParse::entity*)IFC2X3_types[562]); }
Ifc2x3::IfcPlanarExtent::IfcPlanarExtent(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcPlanarExtent::IfcPlanarExtent(double v1_SizeInX, double v2_SizeInY) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (v1_SizeInX));set_attribute_value(1, (v2_SizeInY));; populate_derived(); }

// Function implementations for IfcPlane


const IfcParse::entity& Ifc2x3::IfcPlane::declaration() const { return *((IfcParse::entity*)IFC2X3_types[564]); }
const IfcParse::entity& Ifc2x3::IfcPlane::Class() { return *((IfcParse::entity*)IFC2X3_types[564]); }
Ifc2x3::IfcPlane::IfcPlane(IfcEntityInstanceData&& e) : IfcElementarySurface(std::move(e)) { }
Ifc2x3::IfcPlane::IfcPlane(::Ifc2x3::IfcAxis2Placement3D* v1_Position) : IfcElementarySurface(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, v1_Position ? v1_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcPlate


const IfcParse::entity& Ifc2x3::IfcPlate::declaration() const { return *((IfcParse::entity*)IFC2X3_types[566]); }
const IfcParse::entity& Ifc2x3::IfcPlate::Class() { return *((IfcParse::entity*)IFC2X3_types[566]); }
Ifc2x3::IfcPlate::IfcPlate(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcPlate::IfcPlate(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcPlateType
::Ifc2x3::IfcPlateTypeEnum::Value Ifc2x3::IfcPlateType::PredefinedType() const {  return ::Ifc2x3::IfcPlateTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcPlateType::setPredefinedType(::Ifc2x3::IfcPlateTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcPlateTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcPlateType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[567]); }
const IfcParse::entity& Ifc2x3::IfcPlateType::Class() { return *((IfcParse::entity*)IFC2X3_types[567]); }
Ifc2x3::IfcPlateType::IfcPlateType(IfcEntityInstanceData&& e) : IfcBuildingElementType(std::move(e)) { }
Ifc2x3::IfcPlateType::IfcPlateType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcPlateTypeEnum::Value v10_PredefinedType) : IfcBuildingElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcPlateTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcPoint


const IfcParse::entity& Ifc2x3::IfcPoint::declaration() const { return *((IfcParse::entity*)IFC2X3_types[569]); }
const IfcParse::entity& Ifc2x3::IfcPoint::Class() { return *((IfcParse::entity*)IFC2X3_types[569]); }
Ifc2x3::IfcPoint::IfcPoint(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcPoint::IfcPoint() : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(0))) { ; populate_derived(); }

// Function implementations for IfcPointOnCurve
::Ifc2x3::IfcCurve* Ifc2x3::IfcPointOnCurve::BasisCurve() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcCurve>(true); }
void Ifc2x3::IfcPointOnCurve::setBasisCurve(::Ifc2x3::IfcCurve* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
double Ifc2x3::IfcPointOnCurve::PointParameter() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcPointOnCurve::setPointParameter(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcPointOnCurve::declaration() const { return *((IfcParse::entity*)IFC2X3_types[570]); }
const IfcParse::entity& Ifc2x3::IfcPointOnCurve::Class() { return *((IfcParse::entity*)IFC2X3_types[570]); }
Ifc2x3::IfcPointOnCurve::IfcPointOnCurve(IfcEntityInstanceData&& e) : IfcPoint(std::move(e)) { }
Ifc2x3::IfcPointOnCurve::IfcPointOnCurve(::Ifc2x3::IfcCurve* v1_BasisCurve, double v2_PointParameter) : IfcPoint(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_BasisCurve ? v1_BasisCurve->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_PointParameter));; populate_derived(); }

// Function implementations for IfcPointOnSurface
::Ifc2x3::IfcSurface* Ifc2x3::IfcPointOnSurface::BasisSurface() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcSurface>(true); }
void Ifc2x3::IfcPointOnSurface::setBasisSurface(::Ifc2x3::IfcSurface* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
double Ifc2x3::IfcPointOnSurface::PointParameterU() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcPointOnSurface::setPointParameterU(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
double Ifc2x3::IfcPointOnSurface::PointParameterV() const {  double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcPointOnSurface::setPointParameterV(double v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcPointOnSurface::declaration() const { return *((IfcParse::entity*)IFC2X3_types[571]); }
const IfcParse::entity& Ifc2x3::IfcPointOnSurface::Class() { return *((IfcParse::entity*)IFC2X3_types[571]); }
Ifc2x3::IfcPointOnSurface::IfcPointOnSurface(IfcEntityInstanceData&& e) : IfcPoint(std::move(e)) { }
Ifc2x3::IfcPointOnSurface::IfcPointOnSurface(::Ifc2x3::IfcSurface* v1_BasisSurface, double v2_PointParameterU, double v3_PointParameterV) : IfcPoint(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_BasisSurface ? v1_BasisSurface->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_PointParameterU));set_attribute_value(2, (v3_PointParameterV));; populate_derived(); }

// Function implementations for IfcPolyLoop
aggregate_of< ::Ifc2x3::IfcCartesianPoint >::ptr Ifc2x3::IfcPolyLoop::Polygon() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcCartesianPoint >(); }
void Ifc2x3::IfcPolyLoop::setPolygon(aggregate_of< ::Ifc2x3::IfcCartesianPoint >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcPolyLoop::declaration() const { return *((IfcParse::entity*)IFC2X3_types[575]); }
const IfcParse::entity& Ifc2x3::IfcPolyLoop::Class() { return *((IfcParse::entity*)IFC2X3_types[575]); }
Ifc2x3::IfcPolyLoop::IfcPolyLoop(IfcEntityInstanceData&& e) : IfcLoop(std::move(e)) { }
Ifc2x3::IfcPolyLoop::IfcPolyLoop(aggregate_of< ::Ifc2x3::IfcCartesianPoint >::ptr v1_Polygon) : IfcLoop(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Polygon)->generalize());; populate_derived(); }

// Function implementations for IfcPolygonalBoundedHalfSpace
::Ifc2x3::IfcAxis2Placement3D* Ifc2x3::IfcPolygonalBoundedHalfSpace::Position() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcAxis2Placement3D>(true); }
void Ifc2x3::IfcPolygonalBoundedHalfSpace::setPosition(::Ifc2x3::IfcAxis2Placement3D* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcBoundedCurve* Ifc2x3::IfcPolygonalBoundedHalfSpace::PolygonalBoundary() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcBoundedCurve>(true); }
void Ifc2x3::IfcPolygonalBoundedHalfSpace::setPolygonalBoundary(::Ifc2x3::IfcBoundedCurve* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcPolygonalBoundedHalfSpace::declaration() const { return *((IfcParse::entity*)IFC2X3_types[573]); }
const IfcParse::entity& Ifc2x3::IfcPolygonalBoundedHalfSpace::Class() { return *((IfcParse::entity*)IFC2X3_types[573]); }
Ifc2x3::IfcPolygonalBoundedHalfSpace::IfcPolygonalBoundedHalfSpace(IfcEntityInstanceData&& e) : IfcHalfSpaceSolid(std::move(e)) { }
Ifc2x3::IfcPolygonalBoundedHalfSpace::IfcPolygonalBoundedHalfSpace(::Ifc2x3::IfcSurface* v1_BaseSurface, bool v2_AgreementFlag, ::Ifc2x3::IfcAxis2Placement3D* v3_Position, ::Ifc2x3::IfcBoundedCurve* v4_PolygonalBoundary) : IfcHalfSpaceSolid(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_BaseSurface ? v1_BaseSurface->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_AgreementFlag));set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_PolygonalBoundary ? v4_PolygonalBoundary->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcPolyline
aggregate_of< ::Ifc2x3::IfcCartesianPoint >::ptr Ifc2x3::IfcPolyline::Points() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcCartesianPoint >(); }
void Ifc2x3::IfcPolyline::setPoints(aggregate_of< ::Ifc2x3::IfcCartesianPoint >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcPolyline::declaration() const { return *((IfcParse::entity*)IFC2X3_types[574]); }
const IfcParse::entity& Ifc2x3::IfcPolyline::Class() { return *((IfcParse::entity*)IFC2X3_types[574]); }
Ifc2x3::IfcPolyline::IfcPolyline(IfcEntityInstanceData&& e) : IfcBoundedCurve(std::move(e)) { }
Ifc2x3::IfcPolyline::IfcPolyline(aggregate_of< ::Ifc2x3::IfcCartesianPoint >::ptr v1_Points) : IfcBoundedCurve(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Points)->generalize());; populate_derived(); }

// Function implementations for IfcPort

::Ifc2x3::IfcRelConnectsPortToElement::list::ptr Ifc2x3::IfcPort::ContainedIn() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[692], 4)->as<IfcRelConnectsPortToElement>(); }
::Ifc2x3::IfcRelConnectsPorts::list::ptr Ifc2x3::IfcPort::ConnectedFrom() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[691], 5)->as<IfcRelConnectsPorts>(); }
::Ifc2x3::IfcRelConnectsPorts::list::ptr Ifc2x3::IfcPort::ConnectedTo() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[691], 4)->as<IfcRelConnectsPorts>(); }

const IfcParse::entity& Ifc2x3::IfcPort::declaration() const { return *((IfcParse::entity*)IFC2X3_types[576]); }
const IfcParse::entity& Ifc2x3::IfcPort::Class() { return *((IfcParse::entity*)IFC2X3_types[576]); }
Ifc2x3::IfcPort::IfcPort(IfcEntityInstanceData&& e) : IfcProduct(std::move(e)) { }
Ifc2x3::IfcPort::IfcPort(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation) : IfcProduct(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcPostalAddress
boost::optional< std::string > Ifc2x3::IfcPostalAddress::InternalLocation() const { if(get_attribute_value(3).isNull()) { return boost::none; } std::string v = get_attribute_value(3); return v; }
void Ifc2x3::IfcPostalAddress::setInternalLocation(boost::optional< std::string > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< std::vector< std::string > /*[1:?]*/ > Ifc2x3::IfcPostalAddress::AddressLines() const { if(get_attribute_value(4).isNull()) { return boost::none; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(4); return v; }
void Ifc2x3::IfcPostalAddress::setAddressLines(boost::optional< std::vector< std::string > /*[1:?]*/ > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< std::string > Ifc2x3::IfcPostalAddress::PostalBox() const { if(get_attribute_value(5).isNull()) { return boost::none; } std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcPostalAddress::setPostalBox(boost::optional< std::string > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< std::string > Ifc2x3::IfcPostalAddress::Town() const { if(get_attribute_value(6).isNull()) { return boost::none; } std::string v = get_attribute_value(6); return v; }
void Ifc2x3::IfcPostalAddress::setTown(boost::optional< std::string > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
boost::optional< std::string > Ifc2x3::IfcPostalAddress::Region() const { if(get_attribute_value(7).isNull()) { return boost::none; } std::string v = get_attribute_value(7); return v; }
void Ifc2x3::IfcPostalAddress::setRegion(boost::optional< std::string > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
boost::optional< std::string > Ifc2x3::IfcPostalAddress::PostalCode() const { if(get_attribute_value(8).isNull()) { return boost::none; } std::string v = get_attribute_value(8); return v; }
void Ifc2x3::IfcPostalAddress::setPostalCode(boost::optional< std::string > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
boost::optional< std::string > Ifc2x3::IfcPostalAddress::Country() const { if(get_attribute_value(9).isNull()) { return boost::none; } std::string v = get_attribute_value(9); return v; }
void Ifc2x3::IfcPostalAddress::setCountry(boost::optional< std::string > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }


const IfcParse::entity& Ifc2x3::IfcPostalAddress::declaration() const { return *((IfcParse::entity*)IFC2X3_types[580]); }
const IfcParse::entity& Ifc2x3::IfcPostalAddress::Class() { return *((IfcParse::entity*)IFC2X3_types[580]); }
Ifc2x3::IfcPostalAddress::IfcPostalAddress(IfcEntityInstanceData&& e) : IfcAddress(std::move(e)) { }
Ifc2x3::IfcPostalAddress::IfcPostalAddress(boost::optional< ::Ifc2x3::IfcAddressTypeEnum::Value > v1_Purpose, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_UserDefinedPurpose, boost::optional< std::string > v4_InternalLocation, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_AddressLines, boost::optional< std::string > v6_PostalBox, boost::optional< std::string > v7_Town, boost::optional< std::string > v8_Region, boost::optional< std::string > v9_PostalCode, boost::optional< std::string > v10_Country) : IfcAddress(IfcEntityInstanceData(in_memory_attribute_storage(10))) {  if (v1_Purpose) {set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcAddressTypeEnum::Class(),(size_t)*v1_Purpose))); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); } if (v3_UserDefinedPurpose) {set_attribute_value(2, (*v3_UserDefinedPurpose)); } if (v4_InternalLocation) {set_attribute_value(3, (*v4_InternalLocation)); } if (v5_AddressLines) {set_attribute_value(4, (*v5_AddressLines)); } if (v6_PostalBox) {set_attribute_value(5, (*v6_PostalBox)); } if (v7_Town) {set_attribute_value(6, (*v7_Town)); } if (v8_Region) {set_attribute_value(7, (*v8_Region)); } if (v9_PostalCode) {set_attribute_value(8, (*v9_PostalCode)); } if (v10_Country) {set_attribute_value(9, (*v10_Country)); }; populate_derived(); }

// Function implementations for IfcPreDefinedColour


const IfcParse::entity& Ifc2x3::IfcPreDefinedColour::declaration() const { return *((IfcParse::entity*)IFC2X3_types[582]); }
const IfcParse::entity& Ifc2x3::IfcPreDefinedColour::Class() { return *((IfcParse::entity*)IFC2X3_types[582]); }
Ifc2x3::IfcPreDefinedColour::IfcPreDefinedColour(IfcEntityInstanceData&& e) : IfcPreDefinedItem(std::move(e)) { }
Ifc2x3::IfcPreDefinedColour::IfcPreDefinedColour(std::string v1_Name) : IfcPreDefinedItem(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Name));; populate_derived(); }

// Function implementations for IfcPreDefinedCurveFont


const IfcParse::entity& Ifc2x3::IfcPreDefinedCurveFont::declaration() const { return *((IfcParse::entity*)IFC2X3_types[583]); }
const IfcParse::entity& Ifc2x3::IfcPreDefinedCurveFont::Class() { return *((IfcParse::entity*)IFC2X3_types[583]); }
Ifc2x3::IfcPreDefinedCurveFont::IfcPreDefinedCurveFont(IfcEntityInstanceData&& e) : IfcPreDefinedItem(std::move(e)) { }
Ifc2x3::IfcPreDefinedCurveFont::IfcPreDefinedCurveFont(std::string v1_Name) : IfcPreDefinedItem(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Name));; populate_derived(); }

// Function implementations for IfcPreDefinedDimensionSymbol


const IfcParse::entity& Ifc2x3::IfcPreDefinedDimensionSymbol::declaration() const { return *((IfcParse::entity*)IFC2X3_types[584]); }
const IfcParse::entity& Ifc2x3::IfcPreDefinedDimensionSymbol::Class() { return *((IfcParse::entity*)IFC2X3_types[584]); }
Ifc2x3::IfcPreDefinedDimensionSymbol::IfcPreDefinedDimensionSymbol(IfcEntityInstanceData&& e) : IfcPreDefinedSymbol(std::move(e)) { }
Ifc2x3::IfcPreDefinedDimensionSymbol::IfcPreDefinedDimensionSymbol(std::string v1_Name) : IfcPreDefinedSymbol(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Name));; populate_derived(); }

// Function implementations for IfcPreDefinedItem
std::string Ifc2x3::IfcPreDefinedItem::Name() const {  std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcPreDefinedItem::setName(std::string v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcPreDefinedItem::declaration() const { return *((IfcParse::entity*)IFC2X3_types[585]); }
const IfcParse::entity& Ifc2x3::IfcPreDefinedItem::Class() { return *((IfcParse::entity*)IFC2X3_types[585]); }
Ifc2x3::IfcPreDefinedItem::IfcPreDefinedItem(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcPreDefinedItem::IfcPreDefinedItem(std::string v1_Name) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Name));; populate_derived(); }

// Function implementations for IfcPreDefinedPointMarkerSymbol


const IfcParse::entity& Ifc2x3::IfcPreDefinedPointMarkerSymbol::declaration() const { return *((IfcParse::entity*)IFC2X3_types[586]); }
const IfcParse::entity& Ifc2x3::IfcPreDefinedPointMarkerSymbol::Class() { return *((IfcParse::entity*)IFC2X3_types[586]); }
Ifc2x3::IfcPreDefinedPointMarkerSymbol::IfcPreDefinedPointMarkerSymbol(IfcEntityInstanceData&& e) : IfcPreDefinedSymbol(std::move(e)) { }
Ifc2x3::IfcPreDefinedPointMarkerSymbol::IfcPreDefinedPointMarkerSymbol(std::string v1_Name) : IfcPreDefinedSymbol(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Name));; populate_derived(); }

// Function implementations for IfcPreDefinedSymbol


const IfcParse::entity& Ifc2x3::IfcPreDefinedSymbol::declaration() const { return *((IfcParse::entity*)IFC2X3_types[587]); }
const IfcParse::entity& Ifc2x3::IfcPreDefinedSymbol::Class() { return *((IfcParse::entity*)IFC2X3_types[587]); }
Ifc2x3::IfcPreDefinedSymbol::IfcPreDefinedSymbol(IfcEntityInstanceData&& e) : IfcPreDefinedItem(std::move(e)) { }
Ifc2x3::IfcPreDefinedSymbol::IfcPreDefinedSymbol(std::string v1_Name) : IfcPreDefinedItem(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Name));; populate_derived(); }

// Function implementations for IfcPreDefinedTerminatorSymbol


const IfcParse::entity& Ifc2x3::IfcPreDefinedTerminatorSymbol::declaration() const { return *((IfcParse::entity*)IFC2X3_types[588]); }
const IfcParse::entity& Ifc2x3::IfcPreDefinedTerminatorSymbol::Class() { return *((IfcParse::entity*)IFC2X3_types[588]); }
Ifc2x3::IfcPreDefinedTerminatorSymbol::IfcPreDefinedTerminatorSymbol(IfcEntityInstanceData&& e) : IfcPreDefinedSymbol(std::move(e)) { }
Ifc2x3::IfcPreDefinedTerminatorSymbol::IfcPreDefinedTerminatorSymbol(std::string v1_Name) : IfcPreDefinedSymbol(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Name));; populate_derived(); }

// Function implementations for IfcPreDefinedTextFont


const IfcParse::entity& Ifc2x3::IfcPreDefinedTextFont::declaration() const { return *((IfcParse::entity*)IFC2X3_types[589]); }
const IfcParse::entity& Ifc2x3::IfcPreDefinedTextFont::Class() { return *((IfcParse::entity*)IFC2X3_types[589]); }
Ifc2x3::IfcPreDefinedTextFont::IfcPreDefinedTextFont(IfcEntityInstanceData&& e) : IfcPreDefinedItem(std::move(e)) { }
Ifc2x3::IfcPreDefinedTextFont::IfcPreDefinedTextFont(std::string v1_Name) : IfcPreDefinedItem(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Name));; populate_derived(); }

// Function implementations for IfcPresentationLayerAssignment
std::string Ifc2x3::IfcPresentationLayerAssignment::Name() const {  std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcPresentationLayerAssignment::setName(std::string v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
boost::optional< std::string > Ifc2x3::IfcPresentationLayerAssignment::Description() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcPresentationLayerAssignment::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
aggregate_of< ::Ifc2x3::IfcLayeredItem >::ptr Ifc2x3::IfcPresentationLayerAssignment::AssignedItems() const {  aggregate_of_instance::ptr es = get_attribute_value(2); return es->as< ::Ifc2x3::IfcLayeredItem >(); }
void Ifc2x3::IfcPresentationLayerAssignment::setAssignedItems(aggregate_of< ::Ifc2x3::IfcLayeredItem >::ptr v) { set_attribute_value(2, (v)->generalize());if constexpr (false)unset_attribute_value(2); }
boost::optional< std::string > Ifc2x3::IfcPresentationLayerAssignment::Identifier() const { if(get_attribute_value(3).isNull()) { return boost::none; } std::string v = get_attribute_value(3); return v; }
void Ifc2x3::IfcPresentationLayerAssignment::setIdentifier(boost::optional< std::string > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }


const IfcParse::entity& Ifc2x3::IfcPresentationLayerAssignment::declaration() const { return *((IfcParse::entity*)IFC2X3_types[591]); }
const IfcParse::entity& Ifc2x3::IfcPresentationLayerAssignment::Class() { return *((IfcParse::entity*)IFC2X3_types[591]); }
Ifc2x3::IfcPresentationLayerAssignment::IfcPresentationLayerAssignment(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcPresentationLayerAssignment::IfcPresentationLayerAssignment(std::string v1_Name, boost::optional< std::string > v2_Description, aggregate_of< ::Ifc2x3::IfcLayeredItem >::ptr v3_AssignedItems, boost::optional< std::string > v4_Identifier) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_AssignedItems)->generalize()); if (v4_Identifier) {set_attribute_value(3, (*v4_Identifier)); }; populate_derived(); }

// Function implementations for IfcPresentationLayerWithStyle
boost::logic::tribool Ifc2x3::IfcPresentationLayerWithStyle::LayerOn() const {  boost::logic::tribool v = get_attribute_value(4); return v; }
void Ifc2x3::IfcPresentationLayerWithStyle::setLayerOn(boost::logic::tribool v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
boost::logic::tribool Ifc2x3::IfcPresentationLayerWithStyle::LayerFrozen() const {  boost::logic::tribool v = get_attribute_value(5); return v; }
void Ifc2x3::IfcPresentationLayerWithStyle::setLayerFrozen(boost::logic::tribool v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
boost::logic::tribool Ifc2x3::IfcPresentationLayerWithStyle::LayerBlocked() const {  boost::logic::tribool v = get_attribute_value(6); return v; }
void Ifc2x3::IfcPresentationLayerWithStyle::setLayerBlocked(boost::logic::tribool v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
aggregate_of< ::Ifc2x3::IfcPresentationStyleSelect >::ptr Ifc2x3::IfcPresentationLayerWithStyle::LayerStyles() const {  aggregate_of_instance::ptr es = get_attribute_value(7); return es->as< ::Ifc2x3::IfcPresentationStyleSelect >(); }
void Ifc2x3::IfcPresentationLayerWithStyle::setLayerStyles(aggregate_of< ::Ifc2x3::IfcPresentationStyleSelect >::ptr v) { set_attribute_value(7, (v)->generalize());if constexpr (false)unset_attribute_value(7); }


const IfcParse::entity& Ifc2x3::IfcPresentationLayerWithStyle::declaration() const { return *((IfcParse::entity*)IFC2X3_types[592]); }
const IfcParse::entity& Ifc2x3::IfcPresentationLayerWithStyle::Class() { return *((IfcParse::entity*)IFC2X3_types[592]); }
Ifc2x3::IfcPresentationLayerWithStyle::IfcPresentationLayerWithStyle(IfcEntityInstanceData&& e) : IfcPresentationLayerAssignment(std::move(e)) { }
Ifc2x3::IfcPresentationLayerWithStyle::IfcPresentationLayerWithStyle(std::string v1_Name, boost::optional< std::string > v2_Description, aggregate_of< ::Ifc2x3::IfcLayeredItem >::ptr v3_AssignedItems, boost::optional< std::string > v4_Identifier, boost::logic::tribool v5_LayerOn, boost::logic::tribool v6_LayerFrozen, boost::logic::tribool v7_LayerBlocked, aggregate_of< ::Ifc2x3::IfcPresentationStyleSelect >::ptr v8_LayerStyles) : IfcPresentationLayerAssignment(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_AssignedItems)->generalize()); if (v4_Identifier) {set_attribute_value(3, (*v4_Identifier)); }set_attribute_value(4, (v5_LayerOn));set_attribute_value(5, (v6_LayerFrozen));set_attribute_value(6, (v7_LayerBlocked));set_attribute_value(7, (v8_LayerStyles)->generalize());; populate_derived(); }

// Function implementations for IfcPresentationStyle
boost::optional< std::string > Ifc2x3::IfcPresentationStyle::Name() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcPresentationStyle::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }


const IfcParse::entity& Ifc2x3::IfcPresentationStyle::declaration() const { return *((IfcParse::entity*)IFC2X3_types[593]); }
const IfcParse::entity& Ifc2x3::IfcPresentationStyle::Class() { return *((IfcParse::entity*)IFC2X3_types[593]); }
Ifc2x3::IfcPresentationStyle::IfcPresentationStyle(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcPresentationStyle::IfcPresentationStyle(boost::optional< std::string > v1_Name) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }; populate_derived(); }

// Function implementations for IfcPresentationStyleAssignment
aggregate_of< ::Ifc2x3::IfcPresentationStyleSelect >::ptr Ifc2x3::IfcPresentationStyleAssignment::Styles() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcPresentationStyleSelect >(); }
void Ifc2x3::IfcPresentationStyleAssignment::setStyles(aggregate_of< ::Ifc2x3::IfcPresentationStyleSelect >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcPresentationStyleAssignment::declaration() const { return *((IfcParse::entity*)IFC2X3_types[594]); }
const IfcParse::entity& Ifc2x3::IfcPresentationStyleAssignment::Class() { return *((IfcParse::entity*)IFC2X3_types[594]); }
Ifc2x3::IfcPresentationStyleAssignment::IfcPresentationStyleAssignment(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcPresentationStyleAssignment::IfcPresentationStyleAssignment(aggregate_of< ::Ifc2x3::IfcPresentationStyleSelect >::ptr v1_Styles) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Styles)->generalize());; populate_derived(); }

// Function implementations for IfcProcedure
std::string Ifc2x3::IfcProcedure::ProcedureID() const {  std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcProcedure::setProcedureID(std::string v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcProcedureTypeEnum::Value Ifc2x3::IfcProcedure::ProcedureType() const {  return ::Ifc2x3::IfcProcedureTypeEnum::FromString(get_attribute_value(6)); }
void Ifc2x3::IfcProcedure::setProcedureType(::Ifc2x3::IfcProcedureTypeEnum::Value v) { set_attribute_value(6, EnumerationReference(&::Ifc2x3::IfcProcedureTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(6); }
boost::optional< std::string > Ifc2x3::IfcProcedure::UserDefinedProcedureType() const { if(get_attribute_value(7).isNull()) { return boost::none; } std::string v = get_attribute_value(7); return v; }
void Ifc2x3::IfcProcedure::setUserDefinedProcedureType(boost::optional< std::string > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }


const IfcParse::entity& Ifc2x3::IfcProcedure::declaration() const { return *((IfcParse::entity*)IFC2X3_types[597]); }
const IfcParse::entity& Ifc2x3::IfcProcedure::Class() { return *((IfcParse::entity*)IFC2X3_types[597]); }
Ifc2x3::IfcProcedure::IfcProcedure(IfcEntityInstanceData&& e) : IfcProcess(std::move(e)) { }
Ifc2x3::IfcProcedure::IfcProcedure(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_ProcedureID, ::Ifc2x3::IfcProcedureTypeEnum::Value v7_ProcedureType, boost::optional< std::string > v8_UserDefinedProcedureType) : IfcProcess(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (v6_ProcedureID));set_attribute_value(6, (EnumerationReference(&::Ifc2x3::IfcProcedureTypeEnum::Class(),(size_t)v7_ProcedureType))); if (v8_UserDefinedProcedureType) {set_attribute_value(7, (*v8_UserDefinedProcedureType)); }; populate_derived(); }

// Function implementations for IfcProcess

::Ifc2x3::IfcRelAssignsToProcess::list::ptr Ifc2x3::IfcProcess::OperatesOn() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[673], 6)->as<IfcRelAssignsToProcess>(); }
::Ifc2x3::IfcRelSequence::list::ptr Ifc2x3::IfcProcess::IsSuccessorFrom() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[714], 5)->as<IfcRelSequence>(); }
::Ifc2x3::IfcRelSequence::list::ptr Ifc2x3::IfcProcess::IsPredecessorTo() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[714], 4)->as<IfcRelSequence>(); }

const IfcParse::entity& Ifc2x3::IfcProcess::declaration() const { return *((IfcParse::entity*)IFC2X3_types[599]); }
const IfcParse::entity& Ifc2x3::IfcProcess::Class() { return *((IfcParse::entity*)IFC2X3_types[599]); }
Ifc2x3::IfcProcess::IfcProcess(IfcEntityInstanceData&& e) : IfcObject(std::move(e)) { }
Ifc2x3::IfcProcess::IfcProcess(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcObject(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }; populate_derived(); }

// Function implementations for IfcProduct
::Ifc2x3::IfcObjectPlacement* Ifc2x3::IfcProduct::ObjectPlacement() const { if(get_attribute_value(5).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcObjectPlacement>(true); }
void Ifc2x3::IfcProduct::setObjectPlacement(::Ifc2x3::IfcObjectPlacement* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcProductRepresentation* Ifc2x3::IfcProduct::Representation() const { if(get_attribute_value(6).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcProductRepresentation>(true); }
void Ifc2x3::IfcProduct::setRepresentation(::Ifc2x3::IfcProductRepresentation* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }

::Ifc2x3::IfcRelAssignsToProduct::list::ptr Ifc2x3::IfcProduct::ReferencedBy() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[674], 6)->as<IfcRelAssignsToProduct>(); }

const IfcParse::entity& Ifc2x3::IfcProduct::declaration() const { return *((IfcParse::entity*)IFC2X3_types[600]); }
const IfcParse::entity& Ifc2x3::IfcProduct::Class() { return *((IfcParse::entity*)IFC2X3_types[600]); }
Ifc2x3::IfcProduct::IfcProduct(IfcEntityInstanceData&& e) : IfcObject(std::move(e)) { }
Ifc2x3::IfcProduct::IfcProduct(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation) : IfcObject(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcProductDefinitionShape

::Ifc2x3::IfcProduct::list::ptr Ifc2x3::IfcProductDefinitionShape::ShapeOfProduct() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[600], 6)->as<IfcProduct>(); }
::Ifc2x3::IfcShapeAspect::list::ptr Ifc2x3::IfcProductDefinitionShape::HasShapeAspects() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[755], 4)->as<IfcShapeAspect>(); }

const IfcParse::entity& Ifc2x3::IfcProductDefinitionShape::declaration() const { return *((IfcParse::entity*)IFC2X3_types[601]); }
const IfcParse::entity& Ifc2x3::IfcProductDefinitionShape::Class() { return *((IfcParse::entity*)IFC2X3_types[601]); }
Ifc2x3::IfcProductDefinitionShape::IfcProductDefinitionShape(IfcEntityInstanceData&& e) : IfcProductRepresentation(std::move(e)) { }
Ifc2x3::IfcProductDefinitionShape::IfcProductDefinitionShape(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, aggregate_of< ::Ifc2x3::IfcRepresentation >::ptr v3_Representations) : IfcProductRepresentation(IfcEntityInstanceData(in_memory_attribute_storage(3))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_Representations)->generalize());; populate_derived(); }

// Function implementations for IfcProductRepresentation
boost::optional< std::string > Ifc2x3::IfcProductRepresentation::Name() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcProductRepresentation::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
boost::optional< std::string > Ifc2x3::IfcProductRepresentation::Description() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcProductRepresentation::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
aggregate_of< ::Ifc2x3::IfcRepresentation >::ptr Ifc2x3::IfcProductRepresentation::Representations() const {  aggregate_of_instance::ptr es = get_attribute_value(2); return es->as< ::Ifc2x3::IfcRepresentation >(); }
void Ifc2x3::IfcProductRepresentation::setRepresentations(aggregate_of< ::Ifc2x3::IfcRepresentation >::ptr v) { set_attribute_value(2, (v)->generalize());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcProductRepresentation::declaration() const { return *((IfcParse::entity*)IFC2X3_types[602]); }
const IfcParse::entity& Ifc2x3::IfcProductRepresentation::Class() { return *((IfcParse::entity*)IFC2X3_types[602]); }
Ifc2x3::IfcProductRepresentation::IfcProductRepresentation(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcProductRepresentation::IfcProductRepresentation(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, aggregate_of< ::Ifc2x3::IfcRepresentation >::ptr v3_Representations) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_Representations)->generalize());; populate_derived(); }

// Function implementations for IfcProductsOfCombustionProperties
boost::optional< double > Ifc2x3::IfcProductsOfCombustionProperties::SpecificHeatCapacity() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcProductsOfCombustionProperties::setSpecificHeatCapacity(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcProductsOfCombustionProperties::N20Content() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcProductsOfCombustionProperties::setN20Content(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcProductsOfCombustionProperties::COContent() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcProductsOfCombustionProperties::setCOContent(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< double > Ifc2x3::IfcProductsOfCombustionProperties::CO2Content() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcProductsOfCombustionProperties::setCO2Content(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }


const IfcParse::entity& Ifc2x3::IfcProductsOfCombustionProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[603]); }
const IfcParse::entity& Ifc2x3::IfcProductsOfCombustionProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[603]); }
Ifc2x3::IfcProductsOfCombustionProperties::IfcProductsOfCombustionProperties(IfcEntityInstanceData&& e) : IfcMaterialProperties(std::move(e)) { }
Ifc2x3::IfcProductsOfCombustionProperties::IfcProductsOfCombustionProperties(::Ifc2x3::IfcMaterial* v1_Material, boost::optional< double > v2_SpecificHeatCapacity, boost::optional< double > v3_N20Content, boost::optional< double > v4_COContent, boost::optional< double > v5_CO2Content) : IfcMaterialProperties(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, v1_Material ? v1_Material->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_SpecificHeatCapacity) {set_attribute_value(1, (*v2_SpecificHeatCapacity)); } if (v3_N20Content) {set_attribute_value(2, (*v3_N20Content)); } if (v4_COContent) {set_attribute_value(3, (*v4_COContent)); } if (v5_CO2Content) {set_attribute_value(4, (*v5_CO2Content)); }; populate_derived(); }

// Function implementations for IfcProfileDef
::Ifc2x3::IfcProfileTypeEnum::Value Ifc2x3::IfcProfileDef::ProfileType() const {  return ::Ifc2x3::IfcProfileTypeEnum::FromString(get_attribute_value(0)); }
void Ifc2x3::IfcProfileDef::setProfileType(::Ifc2x3::IfcProfileTypeEnum::Value v) { set_attribute_value(0, EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(0); }
boost::optional< std::string > Ifc2x3::IfcProfileDef::ProfileName() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcProfileDef::setProfileName(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }


const IfcParse::entity& Ifc2x3::IfcProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[604]); }
const IfcParse::entity& Ifc2x3::IfcProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[604]); }
Ifc2x3::IfcProfileDef::IfcProfileDef(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcProfileDef::IfcProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }; populate_derived(); }

// Function implementations for IfcProfileProperties
boost::optional< std::string > Ifc2x3::IfcProfileProperties::ProfileName() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcProfileProperties::setProfileName(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
::Ifc2x3::IfcProfileDef* Ifc2x3::IfcProfileProperties::ProfileDefinition() const { if(get_attribute_value(1).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcProfileDef>(true); }
void Ifc2x3::IfcProfileProperties::setProfileDefinition(::Ifc2x3::IfcProfileDef* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcProfileProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[605]); }
const IfcParse::entity& Ifc2x3::IfcProfileProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[605]); }
Ifc2x3::IfcProfileProperties::IfcProfileProperties(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcProfileProperties::IfcProfileProperties(boost::optional< std::string > v1_ProfileName, ::Ifc2x3::IfcProfileDef* v2_ProfileDefinition) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) {  if (v1_ProfileName) {set_attribute_value(0, (*v1_ProfileName)); }set_attribute_value(1, v2_ProfileDefinition ? v2_ProfileDefinition->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcProject
boost::optional< std::string > Ifc2x3::IfcProject::LongName() const { if(get_attribute_value(5).isNull()) { return boost::none; } std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcProject::setLongName(boost::optional< std::string > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< std::string > Ifc2x3::IfcProject::Phase() const { if(get_attribute_value(6).isNull()) { return boost::none; } std::string v = get_attribute_value(6); return v; }
void Ifc2x3::IfcProject::setPhase(boost::optional< std::string > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
aggregate_of< ::Ifc2x3::IfcRepresentationContext >::ptr Ifc2x3::IfcProject::RepresentationContexts() const {  aggregate_of_instance::ptr es = get_attribute_value(7); return es->as< ::Ifc2x3::IfcRepresentationContext >(); }
void Ifc2x3::IfcProject::setRepresentationContexts(aggregate_of< ::Ifc2x3::IfcRepresentationContext >::ptr v) { set_attribute_value(7, (v)->generalize());if constexpr (false)unset_attribute_value(7); }
::Ifc2x3::IfcUnitAssignment* Ifc2x3::IfcProject::UnitsInContext() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(8)))->as<::Ifc2x3::IfcUnitAssignment>(true); }
void Ifc2x3::IfcProject::setUnitsInContext(::Ifc2x3::IfcUnitAssignment* v) { set_attribute_value(8, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(8); }


const IfcParse::entity& Ifc2x3::IfcProject::declaration() const { return *((IfcParse::entity*)IFC2X3_types[607]); }
const IfcParse::entity& Ifc2x3::IfcProject::Class() { return *((IfcParse::entity*)IFC2X3_types[607]); }
Ifc2x3::IfcProject::IfcProject(IfcEntityInstanceData&& e) : IfcObject(std::move(e)) { }
Ifc2x3::IfcProject::IfcProject(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_LongName, boost::optional< std::string > v7_Phase, aggregate_of< ::Ifc2x3::IfcRepresentationContext >::ptr v8_RepresentationContexts, ::Ifc2x3::IfcUnitAssignment* v9_UnitsInContext) : IfcObject(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); } if (v6_LongName) {set_attribute_value(5, (*v6_LongName)); } if (v7_Phase) {set_attribute_value(6, (*v7_Phase)); }set_attribute_value(7, (v8_RepresentationContexts)->generalize());set_attribute_value(8, v9_UnitsInContext ? v9_UnitsInContext->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcProjectOrder
std::string Ifc2x3::IfcProjectOrder::ID() const {  std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcProjectOrder::setID(std::string v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcProjectOrderTypeEnum::Value Ifc2x3::IfcProjectOrder::PredefinedType() const {  return ::Ifc2x3::IfcProjectOrderTypeEnum::FromString(get_attribute_value(6)); }
void Ifc2x3::IfcProjectOrder::setPredefinedType(::Ifc2x3::IfcProjectOrderTypeEnum::Value v) { set_attribute_value(6, EnumerationReference(&::Ifc2x3::IfcProjectOrderTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(6); }
boost::optional< std::string > Ifc2x3::IfcProjectOrder::Status() const { if(get_attribute_value(7).isNull()) { return boost::none; } std::string v = get_attribute_value(7); return v; }
void Ifc2x3::IfcProjectOrder::setStatus(boost::optional< std::string > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }


const IfcParse::entity& Ifc2x3::IfcProjectOrder::declaration() const { return *((IfcParse::entity*)IFC2X3_types[611]); }
const IfcParse::entity& Ifc2x3::IfcProjectOrder::Class() { return *((IfcParse::entity*)IFC2X3_types[611]); }
Ifc2x3::IfcProjectOrder::IfcProjectOrder(IfcEntityInstanceData&& e) : IfcControl(std::move(e)) { }
Ifc2x3::IfcProjectOrder::IfcProjectOrder(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_ID, ::Ifc2x3::IfcProjectOrderTypeEnum::Value v7_PredefinedType, boost::optional< std::string > v8_Status) : IfcControl(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (v6_ID));set_attribute_value(6, (EnumerationReference(&::Ifc2x3::IfcProjectOrderTypeEnum::Class(),(size_t)v7_PredefinedType))); if (v8_Status) {set_attribute_value(7, (*v8_Status)); }; populate_derived(); }

// Function implementations for IfcProjectOrderRecord
aggregate_of< ::Ifc2x3::IfcRelAssignsToProjectOrder >::ptr Ifc2x3::IfcProjectOrderRecord::Records() const {  aggregate_of_instance::ptr es = get_attribute_value(5); return es->as< ::Ifc2x3::IfcRelAssignsToProjectOrder >(); }
void Ifc2x3::IfcProjectOrderRecord::setRecords(aggregate_of< ::Ifc2x3::IfcRelAssignsToProjectOrder >::ptr v) { set_attribute_value(5, (v)->generalize());if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcProjectOrderRecordTypeEnum::Value Ifc2x3::IfcProjectOrderRecord::PredefinedType() const {  return ::Ifc2x3::IfcProjectOrderRecordTypeEnum::FromString(get_attribute_value(6)); }
void Ifc2x3::IfcProjectOrderRecord::setPredefinedType(::Ifc2x3::IfcProjectOrderRecordTypeEnum::Value v) { set_attribute_value(6, EnumerationReference(&::Ifc2x3::IfcProjectOrderRecordTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcProjectOrderRecord::declaration() const { return *((IfcParse::entity*)IFC2X3_types[612]); }
const IfcParse::entity& Ifc2x3::IfcProjectOrderRecord::Class() { return *((IfcParse::entity*)IFC2X3_types[612]); }
Ifc2x3::IfcProjectOrderRecord::IfcProjectOrderRecord(IfcEntityInstanceData&& e) : IfcControl(std::move(e)) { }
Ifc2x3::IfcProjectOrderRecord::IfcProjectOrderRecord(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, aggregate_of< ::Ifc2x3::IfcRelAssignsToProjectOrder >::ptr v6_Records, ::Ifc2x3::IfcProjectOrderRecordTypeEnum::Value v7_PredefinedType) : IfcControl(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (v6_Records)->generalize());set_attribute_value(6, (EnumerationReference(&::Ifc2x3::IfcProjectOrderRecordTypeEnum::Class(),(size_t)v7_PredefinedType)));; populate_derived(); }

// Function implementations for IfcProjectionCurve


const IfcParse::entity& Ifc2x3::IfcProjectionCurve::declaration() const { return *((IfcParse::entity*)IFC2X3_types[609]); }
const IfcParse::entity& Ifc2x3::IfcProjectionCurve::Class() { return *((IfcParse::entity*)IFC2X3_types[609]); }
Ifc2x3::IfcProjectionCurve::IfcProjectionCurve(IfcEntityInstanceData&& e) : IfcAnnotationCurveOccurrence(std::move(e)) { }
Ifc2x3::IfcProjectionCurve::IfcProjectionCurve(::Ifc2x3::IfcRepresentationItem* v1_Item, aggregate_of< ::Ifc2x3::IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcAnnotationCurveOccurrence(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_Item ? v1_Item->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Styles)->generalize()); if (v3_Name) {set_attribute_value(2, (*v3_Name)); }; populate_derived(); }

// Function implementations for IfcProjectionElement


const IfcParse::entity& Ifc2x3::IfcProjectionElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[610]); }
const IfcParse::entity& Ifc2x3::IfcProjectionElement::Class() { return *((IfcParse::entity*)IFC2X3_types[610]); }
Ifc2x3::IfcProjectionElement::IfcProjectionElement(IfcEntityInstanceData&& e) : IfcFeatureElementAddition(std::move(e)) { }
Ifc2x3::IfcProjectionElement::IfcProjectionElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcFeatureElementAddition(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcProperty
std::string Ifc2x3::IfcProperty::Name() const {  std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcProperty::setName(std::string v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
boost::optional< std::string > Ifc2x3::IfcProperty::Description() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcProperty::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }

::Ifc2x3::IfcPropertyDependencyRelationship::list::ptr Ifc2x3::IfcProperty::PropertyForDependance() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[619], 0)->as<IfcPropertyDependencyRelationship>(); }
::Ifc2x3::IfcPropertyDependencyRelationship::list::ptr Ifc2x3::IfcProperty::PropertyDependsOn() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[619], 1)->as<IfcPropertyDependencyRelationship>(); }
::Ifc2x3::IfcComplexProperty::list::ptr Ifc2x3::IfcProperty::PartOfComplex() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[131], 3)->as<IfcComplexProperty>(); }

const IfcParse::entity& Ifc2x3::IfcProperty::declaration() const { return *((IfcParse::entity*)IFC2X3_types[615]); }
const IfcParse::entity& Ifc2x3::IfcProperty::Class() { return *((IfcParse::entity*)IFC2X3_types[615]); }
Ifc2x3::IfcProperty::IfcProperty(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcProperty::IfcProperty(std::string v1_Name, boost::optional< std::string > v2_Description) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }; populate_derived(); }

// Function implementations for IfcPropertyBoundedValue
::Ifc2x3::IfcValue* Ifc2x3::IfcPropertyBoundedValue::UpperBoundValue() const { if(get_attribute_value(2).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcValue>(true); }
void Ifc2x3::IfcPropertyBoundedValue::setUpperBoundValue(::Ifc2x3::IfcValue* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcValue* Ifc2x3::IfcPropertyBoundedValue::LowerBoundValue() const { if(get_attribute_value(3).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcValue>(true); }
void Ifc2x3::IfcPropertyBoundedValue::setLowerBoundValue(::Ifc2x3::IfcValue* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }
::Ifc2x3::IfcUnit* Ifc2x3::IfcPropertyBoundedValue::Unit() const { if(get_attribute_value(4).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcUnit>(true); }
void Ifc2x3::IfcPropertyBoundedValue::setUnit(::Ifc2x3::IfcUnit* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcPropertyBoundedValue::declaration() const { return *((IfcParse::entity*)IFC2X3_types[616]); }
const IfcParse::entity& Ifc2x3::IfcPropertyBoundedValue::Class() { return *((IfcParse::entity*)IFC2X3_types[616]); }
Ifc2x3::IfcPropertyBoundedValue::IfcPropertyBoundedValue(IfcEntityInstanceData&& e) : IfcSimpleProperty(std::move(e)) { }
Ifc2x3::IfcPropertyBoundedValue::IfcPropertyBoundedValue(std::string v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcValue* v3_UpperBoundValue, ::Ifc2x3::IfcValue* v4_LowerBoundValue, ::Ifc2x3::IfcUnit* v5_Unit) : IfcSimpleProperty(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_UpperBoundValue ? v3_UpperBoundValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_LowerBoundValue ? v4_LowerBoundValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(4, v5_Unit ? v5_Unit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcPropertyConstraintRelationship
::Ifc2x3::IfcConstraint* Ifc2x3::IfcPropertyConstraintRelationship::RelatingConstraint() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcConstraint>(true); }
void Ifc2x3::IfcPropertyConstraintRelationship::setRelatingConstraint(::Ifc2x3::IfcConstraint* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcProperty >::ptr Ifc2x3::IfcPropertyConstraintRelationship::RelatedProperties() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcProperty >(); }
void Ifc2x3::IfcPropertyConstraintRelationship::setRelatedProperties(aggregate_of< ::Ifc2x3::IfcProperty >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }
boost::optional< std::string > Ifc2x3::IfcPropertyConstraintRelationship::Name() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcPropertyConstraintRelationship::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< std::string > Ifc2x3::IfcPropertyConstraintRelationship::Description() const { if(get_attribute_value(3).isNull()) { return boost::none; } std::string v = get_attribute_value(3); return v; }
void Ifc2x3::IfcPropertyConstraintRelationship::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }


const IfcParse::entity& Ifc2x3::IfcPropertyConstraintRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[617]); }
const IfcParse::entity& Ifc2x3::IfcPropertyConstraintRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[617]); }
Ifc2x3::IfcPropertyConstraintRelationship::IfcPropertyConstraintRelationship(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcPropertyConstraintRelationship::IfcPropertyConstraintRelationship(::Ifc2x3::IfcConstraint* v1_RelatingConstraint, aggregate_of< ::Ifc2x3::IfcProperty >::ptr v2_RelatedProperties, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_RelatingConstraint ? v1_RelatingConstraint->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_RelatedProperties)->generalize()); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }; populate_derived(); }

// Function implementations for IfcPropertyDefinition

::Ifc2x3::IfcRelAssociates::list::ptr Ifc2x3::IfcPropertyDefinition::HasAssociations() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[677], 4)->as<IfcRelAssociates>(); }

const IfcParse::entity& Ifc2x3::IfcPropertyDefinition::declaration() const { return *((IfcParse::entity*)IFC2X3_types[618]); }
const IfcParse::entity& Ifc2x3::IfcPropertyDefinition::Class() { return *((IfcParse::entity*)IFC2X3_types[618]); }
Ifc2x3::IfcPropertyDefinition::IfcPropertyDefinition(IfcEntityInstanceData&& e) : IfcRoot(std::move(e)) { }
Ifc2x3::IfcPropertyDefinition::IfcPropertyDefinition(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcRoot(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }; populate_derived(); }

// Function implementations for IfcPropertyDependencyRelationship
::Ifc2x3::IfcProperty* Ifc2x3::IfcPropertyDependencyRelationship::DependingProperty() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcProperty>(true); }
void Ifc2x3::IfcPropertyDependencyRelationship::setDependingProperty(::Ifc2x3::IfcProperty* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcProperty* Ifc2x3::IfcPropertyDependencyRelationship::DependantProperty() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcProperty>(true); }
void Ifc2x3::IfcPropertyDependencyRelationship::setDependantProperty(::Ifc2x3::IfcProperty* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
boost::optional< std::string > Ifc2x3::IfcPropertyDependencyRelationship::Name() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcPropertyDependencyRelationship::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< std::string > Ifc2x3::IfcPropertyDependencyRelationship::Description() const { if(get_attribute_value(3).isNull()) { return boost::none; } std::string v = get_attribute_value(3); return v; }
void Ifc2x3::IfcPropertyDependencyRelationship::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< std::string > Ifc2x3::IfcPropertyDependencyRelationship::Expression() const { if(get_attribute_value(4).isNull()) { return boost::none; } std::string v = get_attribute_value(4); return v; }
void Ifc2x3::IfcPropertyDependencyRelationship::setExpression(boost::optional< std::string > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }


const IfcParse::entity& Ifc2x3::IfcPropertyDependencyRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[619]); }
const IfcParse::entity& Ifc2x3::IfcPropertyDependencyRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[619]); }
Ifc2x3::IfcPropertyDependencyRelationship::IfcPropertyDependencyRelationship(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcPropertyDependencyRelationship::IfcPropertyDependencyRelationship(::Ifc2x3::IfcProperty* v1_DependingProperty, ::Ifc2x3::IfcProperty* v2_DependantProperty, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_Expression) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, v1_DependingProperty ? v1_DependingProperty->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_DependantProperty ? v2_DependantProperty->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_Expression) {set_attribute_value(4, (*v5_Expression)); }; populate_derived(); }

// Function implementations for IfcPropertyEnumeratedValue
aggregate_of< ::Ifc2x3::IfcValue >::ptr Ifc2x3::IfcPropertyEnumeratedValue::EnumerationValues() const {  aggregate_of_instance::ptr es = get_attribute_value(2); return es->as< ::Ifc2x3::IfcValue >(); }
void Ifc2x3::IfcPropertyEnumeratedValue::setEnumerationValues(aggregate_of< ::Ifc2x3::IfcValue >::ptr v) { set_attribute_value(2, (v)->generalize());if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcPropertyEnumeration* Ifc2x3::IfcPropertyEnumeratedValue::EnumerationReference() const { if(get_attribute_value(3).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcPropertyEnumeration>(true); }
void Ifc2x3::IfcPropertyEnumeratedValue::setEnumerationReference(::Ifc2x3::IfcPropertyEnumeration* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcPropertyEnumeratedValue::declaration() const { return *((IfcParse::entity*)IFC2X3_types[620]); }
const IfcParse::entity& Ifc2x3::IfcPropertyEnumeratedValue::Class() { return *((IfcParse::entity*)IFC2X3_types[620]); }
Ifc2x3::IfcPropertyEnumeratedValue::IfcPropertyEnumeratedValue(IfcEntityInstanceData&& e) : IfcSimpleProperty(std::move(e)) { }
Ifc2x3::IfcPropertyEnumeratedValue::IfcPropertyEnumeratedValue(std::string v1_Name, boost::optional< std::string > v2_Description, aggregate_of< ::Ifc2x3::IfcValue >::ptr v3_EnumerationValues, ::Ifc2x3::IfcPropertyEnumeration* v4_EnumerationReference) : IfcSimpleProperty(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_EnumerationValues)->generalize());set_attribute_value(3, v4_EnumerationReference ? v4_EnumerationReference->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcPropertyEnumeration
std::string Ifc2x3::IfcPropertyEnumeration::Name() const {  std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcPropertyEnumeration::setName(std::string v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcValue >::ptr Ifc2x3::IfcPropertyEnumeration::EnumerationValues() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcValue >(); }
void Ifc2x3::IfcPropertyEnumeration::setEnumerationValues(aggregate_of< ::Ifc2x3::IfcValue >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcUnit* Ifc2x3::IfcPropertyEnumeration::Unit() const { if(get_attribute_value(2).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcUnit>(true); }
void Ifc2x3::IfcPropertyEnumeration::setUnit(::Ifc2x3::IfcUnit* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcPropertyEnumeration::declaration() const { return *((IfcParse::entity*)IFC2X3_types[621]); }
const IfcParse::entity& Ifc2x3::IfcPropertyEnumeration::Class() { return *((IfcParse::entity*)IFC2X3_types[621]); }
Ifc2x3::IfcPropertyEnumeration::IfcPropertyEnumeration(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcPropertyEnumeration::IfcPropertyEnumeration(std::string v1_Name, aggregate_of< ::Ifc2x3::IfcValue >::ptr v2_EnumerationValues, ::Ifc2x3::IfcUnit* v3_Unit) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, (v1_Name));set_attribute_value(1, (v2_EnumerationValues)->generalize());set_attribute_value(2, v3_Unit ? v3_Unit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcPropertyListValue
aggregate_of< ::Ifc2x3::IfcValue >::ptr Ifc2x3::IfcPropertyListValue::ListValues() const {  aggregate_of_instance::ptr es = get_attribute_value(2); return es->as< ::Ifc2x3::IfcValue >(); }
void Ifc2x3::IfcPropertyListValue::setListValues(aggregate_of< ::Ifc2x3::IfcValue >::ptr v) { set_attribute_value(2, (v)->generalize());if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcUnit* Ifc2x3::IfcPropertyListValue::Unit() const { if(get_attribute_value(3).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcUnit>(true); }
void Ifc2x3::IfcPropertyListValue::setUnit(::Ifc2x3::IfcUnit* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcPropertyListValue::declaration() const { return *((IfcParse::entity*)IFC2X3_types[622]); }
const IfcParse::entity& Ifc2x3::IfcPropertyListValue::Class() { return *((IfcParse::entity*)IFC2X3_types[622]); }
Ifc2x3::IfcPropertyListValue::IfcPropertyListValue(IfcEntityInstanceData&& e) : IfcSimpleProperty(std::move(e)) { }
Ifc2x3::IfcPropertyListValue::IfcPropertyListValue(std::string v1_Name, boost::optional< std::string > v2_Description, aggregate_of< ::Ifc2x3::IfcValue >::ptr v3_ListValues, ::Ifc2x3::IfcUnit* v4_Unit) : IfcSimpleProperty(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_ListValues)->generalize());set_attribute_value(3, v4_Unit ? v4_Unit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcPropertyReferenceValue
boost::optional< std::string > Ifc2x3::IfcPropertyReferenceValue::UsageName() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcPropertyReferenceValue::setUsageName(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
::Ifc2x3::IfcObjectReferenceSelect* Ifc2x3::IfcPropertyReferenceValue::PropertyReference() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcObjectReferenceSelect>(true); }
void Ifc2x3::IfcPropertyReferenceValue::setPropertyReference(::Ifc2x3::IfcObjectReferenceSelect* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcPropertyReferenceValue::declaration() const { return *((IfcParse::entity*)IFC2X3_types[623]); }
const IfcParse::entity& Ifc2x3::IfcPropertyReferenceValue::Class() { return *((IfcParse::entity*)IFC2X3_types[623]); }
Ifc2x3::IfcPropertyReferenceValue::IfcPropertyReferenceValue(IfcEntityInstanceData&& e) : IfcSimpleProperty(std::move(e)) { }
Ifc2x3::IfcPropertyReferenceValue::IfcPropertyReferenceValue(std::string v1_Name, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_UsageName, ::Ifc2x3::IfcObjectReferenceSelect* v4_PropertyReference) : IfcSimpleProperty(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); } if (v3_UsageName) {set_attribute_value(2, (*v3_UsageName)); }set_attribute_value(3, v4_PropertyReference ? v4_PropertyReference->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcPropertySet
aggregate_of< ::Ifc2x3::IfcProperty >::ptr Ifc2x3::IfcPropertySet::HasProperties() const {  aggregate_of_instance::ptr es = get_attribute_value(4); return es->as< ::Ifc2x3::IfcProperty >(); }
void Ifc2x3::IfcPropertySet::setHasProperties(aggregate_of< ::Ifc2x3::IfcProperty >::ptr v) { set_attribute_value(4, (v)->generalize());if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcPropertySet::declaration() const { return *((IfcParse::entity*)IFC2X3_types[624]); }
const IfcParse::entity& Ifc2x3::IfcPropertySet::Class() { return *((IfcParse::entity*)IFC2X3_types[624]); }
Ifc2x3::IfcPropertySet::IfcPropertySet(IfcEntityInstanceData&& e) : IfcPropertySetDefinition(std::move(e)) { }
Ifc2x3::IfcPropertySet::IfcPropertySet(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcProperty >::ptr v5_HasProperties) : IfcPropertySetDefinition(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_HasProperties)->generalize());; populate_derived(); }

// Function implementations for IfcPropertySetDefinition

::Ifc2x3::IfcRelDefinesByProperties::list::ptr Ifc2x3::IfcPropertySetDefinition::PropertyDefinitionOf() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[703], 5)->as<IfcRelDefinesByProperties>(); }
::Ifc2x3::IfcTypeObject::list::ptr Ifc2x3::IfcPropertySetDefinition::DefinesType() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[932], 5)->as<IfcTypeObject>(); }

const IfcParse::entity& Ifc2x3::IfcPropertySetDefinition::declaration() const { return *((IfcParse::entity*)IFC2X3_types[625]); }
const IfcParse::entity& Ifc2x3::IfcPropertySetDefinition::Class() { return *((IfcParse::entity*)IFC2X3_types[625]); }
Ifc2x3::IfcPropertySetDefinition::IfcPropertySetDefinition(IfcEntityInstanceData&& e) : IfcPropertyDefinition(std::move(e)) { }
Ifc2x3::IfcPropertySetDefinition::IfcPropertySetDefinition(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcPropertyDefinition(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }; populate_derived(); }

// Function implementations for IfcPropertySingleValue
::Ifc2x3::IfcValue* Ifc2x3::IfcPropertySingleValue::NominalValue() const { if(get_attribute_value(2).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcValue>(true); }
void Ifc2x3::IfcPropertySingleValue::setNominalValue(::Ifc2x3::IfcValue* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcUnit* Ifc2x3::IfcPropertySingleValue::Unit() const { if(get_attribute_value(3).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcUnit>(true); }
void Ifc2x3::IfcPropertySingleValue::setUnit(::Ifc2x3::IfcUnit* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcPropertySingleValue::declaration() const { return *((IfcParse::entity*)IFC2X3_types[626]); }
const IfcParse::entity& Ifc2x3::IfcPropertySingleValue::Class() { return *((IfcParse::entity*)IFC2X3_types[626]); }
Ifc2x3::IfcPropertySingleValue::IfcPropertySingleValue(IfcEntityInstanceData&& e) : IfcSimpleProperty(std::move(e)) { }
Ifc2x3::IfcPropertySingleValue::IfcPropertySingleValue(std::string v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcValue* v3_NominalValue, ::Ifc2x3::IfcUnit* v4_Unit) : IfcSimpleProperty(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_NominalValue ? v3_NominalValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_Unit ? v4_Unit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcPropertyTableValue
aggregate_of< ::Ifc2x3::IfcValue >::ptr Ifc2x3::IfcPropertyTableValue::DefiningValues() const {  aggregate_of_instance::ptr es = get_attribute_value(2); return es->as< ::Ifc2x3::IfcValue >(); }
void Ifc2x3::IfcPropertyTableValue::setDefiningValues(aggregate_of< ::Ifc2x3::IfcValue >::ptr v) { set_attribute_value(2, (v)->generalize());if constexpr (false)unset_attribute_value(2); }
aggregate_of< ::Ifc2x3::IfcValue >::ptr Ifc2x3::IfcPropertyTableValue::DefinedValues() const {  aggregate_of_instance::ptr es = get_attribute_value(3); return es->as< ::Ifc2x3::IfcValue >(); }
void Ifc2x3::IfcPropertyTableValue::setDefinedValues(aggregate_of< ::Ifc2x3::IfcValue >::ptr v) { set_attribute_value(3, (v)->generalize());if constexpr (false)unset_attribute_value(3); }
boost::optional< std::string > Ifc2x3::IfcPropertyTableValue::Expression() const { if(get_attribute_value(4).isNull()) { return boost::none; } std::string v = get_attribute_value(4); return v; }
void Ifc2x3::IfcPropertyTableValue::setExpression(boost::optional< std::string > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
::Ifc2x3::IfcUnit* Ifc2x3::IfcPropertyTableValue::DefiningUnit() const { if(get_attribute_value(5).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcUnit>(true); }
void Ifc2x3::IfcPropertyTableValue::setDefiningUnit(::Ifc2x3::IfcUnit* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcUnit* Ifc2x3::IfcPropertyTableValue::DefinedUnit() const { if(get_attribute_value(6).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcUnit>(true); }
void Ifc2x3::IfcPropertyTableValue::setDefinedUnit(::Ifc2x3::IfcUnit* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcPropertyTableValue::declaration() const { return *((IfcParse::entity*)IFC2X3_types[628]); }
const IfcParse::entity& Ifc2x3::IfcPropertyTableValue::Class() { return *((IfcParse::entity*)IFC2X3_types[628]); }
Ifc2x3::IfcPropertyTableValue::IfcPropertyTableValue(IfcEntityInstanceData&& e) : IfcSimpleProperty(std::move(e)) { }
Ifc2x3::IfcPropertyTableValue::IfcPropertyTableValue(std::string v1_Name, boost::optional< std::string > v2_Description, aggregate_of< ::Ifc2x3::IfcValue >::ptr v3_DefiningValues, aggregate_of< ::Ifc2x3::IfcValue >::ptr v4_DefinedValues, boost::optional< std::string > v5_Expression, ::Ifc2x3::IfcUnit* v6_DefiningUnit, ::Ifc2x3::IfcUnit* v7_DefinedUnit) : IfcSimpleProperty(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_DefiningValues)->generalize());set_attribute_value(3, (v4_DefinedValues)->generalize()); if (v5_Expression) {set_attribute_value(4, (*v5_Expression)); }set_attribute_value(5, v6_DefiningUnit ? v6_DefiningUnit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_DefinedUnit ? v7_DefinedUnit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcProtectiveDeviceType
::Ifc2x3::IfcProtectiveDeviceTypeEnum::Value Ifc2x3::IfcProtectiveDeviceType::PredefinedType() const {  return ::Ifc2x3::IfcProtectiveDeviceTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcProtectiveDeviceType::setPredefinedType(::Ifc2x3::IfcProtectiveDeviceTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcProtectiveDeviceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcProtectiveDeviceType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[629]); }
const IfcParse::entity& Ifc2x3::IfcProtectiveDeviceType::Class() { return *((IfcParse::entity*)IFC2X3_types[629]); }
Ifc2x3::IfcProtectiveDeviceType::IfcProtectiveDeviceType(IfcEntityInstanceData&& e) : IfcFlowControllerType(std::move(e)) { }
Ifc2x3::IfcProtectiveDeviceType::IfcProtectiveDeviceType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcProtectiveDeviceTypeEnum::Value v10_PredefinedType) : IfcFlowControllerType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcProtectiveDeviceTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcProxy
::Ifc2x3::IfcObjectTypeEnum::Value Ifc2x3::IfcProxy::ProxyType() const {  return ::Ifc2x3::IfcObjectTypeEnum::FromString(get_attribute_value(7)); }
void Ifc2x3::IfcProxy::setProxyType(::Ifc2x3::IfcObjectTypeEnum::Value v) { set_attribute_value(7, EnumerationReference(&::Ifc2x3::IfcObjectTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }
boost::optional< std::string > Ifc2x3::IfcProxy::Tag() const { if(get_attribute_value(8).isNull()) { return boost::none; } std::string v = get_attribute_value(8); return v; }
void Ifc2x3::IfcProxy::setTag(boost::optional< std::string > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }


const IfcParse::entity& Ifc2x3::IfcProxy::declaration() const { return *((IfcParse::entity*)IFC2X3_types[631]); }
const IfcParse::entity& Ifc2x3::IfcProxy::Class() { return *((IfcParse::entity*)IFC2X3_types[631]); }
Ifc2x3::IfcProxy::IfcProxy(IfcEntityInstanceData&& e) : IfcProduct(std::move(e)) { }
Ifc2x3::IfcProxy::IfcProxy(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcObjectTypeEnum::Value v8_ProxyType, boost::optional< std::string > v9_Tag) : IfcProduct(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcObjectTypeEnum::Class(),(size_t)v8_ProxyType))); if (v9_Tag) {set_attribute_value(8, (*v9_Tag)); }; populate_derived(); }

// Function implementations for IfcPumpType
::Ifc2x3::IfcPumpTypeEnum::Value Ifc2x3::IfcPumpType::PredefinedType() const {  return ::Ifc2x3::IfcPumpTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcPumpType::setPredefinedType(::Ifc2x3::IfcPumpTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcPumpTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcPumpType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[632]); }
const IfcParse::entity& Ifc2x3::IfcPumpType::Class() { return *((IfcParse::entity*)IFC2X3_types[632]); }
Ifc2x3::IfcPumpType::IfcPumpType(IfcEntityInstanceData&& e) : IfcFlowMovingDeviceType(std::move(e)) { }
Ifc2x3::IfcPumpType::IfcPumpType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcPumpTypeEnum::Value v10_PredefinedType) : IfcFlowMovingDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcPumpTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcQuantityArea
double Ifc2x3::IfcQuantityArea::AreaValue() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcQuantityArea::setAreaValue(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcQuantityArea::declaration() const { return *((IfcParse::entity*)IFC2X3_types[634]); }
const IfcParse::entity& Ifc2x3::IfcQuantityArea::Class() { return *((IfcParse::entity*)IFC2X3_types[634]); }
Ifc2x3::IfcQuantityArea::IfcQuantityArea(IfcEntityInstanceData&& e) : IfcPhysicalSimpleQuantity(std::move(e)) { }
Ifc2x3::IfcQuantityArea::IfcQuantityArea(std::string v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcNamedUnit* v3_Unit, double v4_AreaValue) : IfcPhysicalSimpleQuantity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_Unit ? v3_Unit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_AreaValue));; populate_derived(); }

// Function implementations for IfcQuantityCount
double Ifc2x3::IfcQuantityCount::CountValue() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcQuantityCount::setCountValue(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcQuantityCount::declaration() const { return *((IfcParse::entity*)IFC2X3_types[635]); }
const IfcParse::entity& Ifc2x3::IfcQuantityCount::Class() { return *((IfcParse::entity*)IFC2X3_types[635]); }
Ifc2x3::IfcQuantityCount::IfcQuantityCount(IfcEntityInstanceData&& e) : IfcPhysicalSimpleQuantity(std::move(e)) { }
Ifc2x3::IfcQuantityCount::IfcQuantityCount(std::string v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcNamedUnit* v3_Unit, double v4_CountValue) : IfcPhysicalSimpleQuantity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_Unit ? v3_Unit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_CountValue));; populate_derived(); }

// Function implementations for IfcQuantityLength
double Ifc2x3::IfcQuantityLength::LengthValue() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcQuantityLength::setLengthValue(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcQuantityLength::declaration() const { return *((IfcParse::entity*)IFC2X3_types[636]); }
const IfcParse::entity& Ifc2x3::IfcQuantityLength::Class() { return *((IfcParse::entity*)IFC2X3_types[636]); }
Ifc2x3::IfcQuantityLength::IfcQuantityLength(IfcEntityInstanceData&& e) : IfcPhysicalSimpleQuantity(std::move(e)) { }
Ifc2x3::IfcQuantityLength::IfcQuantityLength(std::string v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcNamedUnit* v3_Unit, double v4_LengthValue) : IfcPhysicalSimpleQuantity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_Unit ? v3_Unit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_LengthValue));; populate_derived(); }

// Function implementations for IfcQuantityTime
double Ifc2x3::IfcQuantityTime::TimeValue() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcQuantityTime::setTimeValue(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcQuantityTime::declaration() const { return *((IfcParse::entity*)IFC2X3_types[637]); }
const IfcParse::entity& Ifc2x3::IfcQuantityTime::Class() { return *((IfcParse::entity*)IFC2X3_types[637]); }
Ifc2x3::IfcQuantityTime::IfcQuantityTime(IfcEntityInstanceData&& e) : IfcPhysicalSimpleQuantity(std::move(e)) { }
Ifc2x3::IfcQuantityTime::IfcQuantityTime(std::string v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcNamedUnit* v3_Unit, double v4_TimeValue) : IfcPhysicalSimpleQuantity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_Unit ? v3_Unit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_TimeValue));; populate_derived(); }

// Function implementations for IfcQuantityVolume
double Ifc2x3::IfcQuantityVolume::VolumeValue() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcQuantityVolume::setVolumeValue(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcQuantityVolume::declaration() const { return *((IfcParse::entity*)IFC2X3_types[638]); }
const IfcParse::entity& Ifc2x3::IfcQuantityVolume::Class() { return *((IfcParse::entity*)IFC2X3_types[638]); }
Ifc2x3::IfcQuantityVolume::IfcQuantityVolume(IfcEntityInstanceData&& e) : IfcPhysicalSimpleQuantity(std::move(e)) { }
Ifc2x3::IfcQuantityVolume::IfcQuantityVolume(std::string v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcNamedUnit* v3_Unit, double v4_VolumeValue) : IfcPhysicalSimpleQuantity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_Unit ? v3_Unit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_VolumeValue));; populate_derived(); }

// Function implementations for IfcQuantityWeight
double Ifc2x3::IfcQuantityWeight::WeightValue() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcQuantityWeight::setWeightValue(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcQuantityWeight::declaration() const { return *((IfcParse::entity*)IFC2X3_types[639]); }
const IfcParse::entity& Ifc2x3::IfcQuantityWeight::Class() { return *((IfcParse::entity*)IFC2X3_types[639]); }
Ifc2x3::IfcQuantityWeight::IfcQuantityWeight(IfcEntityInstanceData&& e) : IfcPhysicalSimpleQuantity(std::move(e)) { }
Ifc2x3::IfcQuantityWeight::IfcQuantityWeight(std::string v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcNamedUnit* v3_Unit, double v4_WeightValue) : IfcPhysicalSimpleQuantity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_Unit ? v3_Unit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_WeightValue));; populate_derived(); }

// Function implementations for IfcRadiusDimension


const IfcParse::entity& Ifc2x3::IfcRadiusDimension::declaration() const { return *((IfcParse::entity*)IFC2X3_types[641]); }
const IfcParse::entity& Ifc2x3::IfcRadiusDimension::Class() { return *((IfcParse::entity*)IFC2X3_types[641]); }
Ifc2x3::IfcRadiusDimension::IfcRadiusDimension(IfcEntityInstanceData&& e) : IfcDimensionCurveDirectedCallout(std::move(e)) { }
Ifc2x3::IfcRadiusDimension::IfcRadiusDimension(aggregate_of< ::Ifc2x3::IfcDraughtingCalloutElement >::ptr v1_Contents) : IfcDimensionCurveDirectedCallout(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Contents)->generalize());; populate_derived(); }

// Function implementations for IfcRailing
boost::optional< ::Ifc2x3::IfcRailingTypeEnum::Value > Ifc2x3::IfcRailing::PredefinedType() const { if(get_attribute_value(8).isNull()) { return boost::none; } return ::Ifc2x3::IfcRailingTypeEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcRailing::setPredefinedType(boost::optional< ::Ifc2x3::IfcRailingTypeEnum::Value > v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcRailingTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }


const IfcParse::entity& Ifc2x3::IfcRailing::declaration() const { return *((IfcParse::entity*)IFC2X3_types[642]); }
const IfcParse::entity& Ifc2x3::IfcRailing::Class() { return *((IfcParse::entity*)IFC2X3_types[642]); }
Ifc2x3::IfcRailing::IfcRailing(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcRailing::IfcRailing(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< ::Ifc2x3::IfcRailingTypeEnum::Value > v9_PredefinedType) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcRailingTypeEnum::Class(),(size_t)*v9_PredefinedType))); }; populate_derived(); }

// Function implementations for IfcRailingType
::Ifc2x3::IfcRailingTypeEnum::Value Ifc2x3::IfcRailingType::PredefinedType() const {  return ::Ifc2x3::IfcRailingTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcRailingType::setPredefinedType(::Ifc2x3::IfcRailingTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcRailingTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcRailingType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[643]); }
const IfcParse::entity& Ifc2x3::IfcRailingType::Class() { return *((IfcParse::entity*)IFC2X3_types[643]); }
Ifc2x3::IfcRailingType::IfcRailingType(IfcEntityInstanceData&& e) : IfcBuildingElementType(std::move(e)) { }
Ifc2x3::IfcRailingType::IfcRailingType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcRailingTypeEnum::Value v10_PredefinedType) : IfcBuildingElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcRailingTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcRamp
::Ifc2x3::IfcRampTypeEnum::Value Ifc2x3::IfcRamp::ShapeType() const {  return ::Ifc2x3::IfcRampTypeEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcRamp::setShapeType(::Ifc2x3::IfcRampTypeEnum::Value v) { set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcRampTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }


const IfcParse::entity& Ifc2x3::IfcRamp::declaration() const { return *((IfcParse::entity*)IFC2X3_types[645]); }
const IfcParse::entity& Ifc2x3::IfcRamp::Class() { return *((IfcParse::entity*)IFC2X3_types[645]); }
Ifc2x3::IfcRamp::IfcRamp(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcRamp::IfcRamp(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, ::Ifc2x3::IfcRampTypeEnum::Value v9_ShapeType) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcRampTypeEnum::Class(),(size_t)v9_ShapeType)));; populate_derived(); }

// Function implementations for IfcRampFlight


const IfcParse::entity& Ifc2x3::IfcRampFlight::declaration() const { return *((IfcParse::entity*)IFC2X3_types[646]); }
const IfcParse::entity& Ifc2x3::IfcRampFlight::Class() { return *((IfcParse::entity*)IFC2X3_types[646]); }
Ifc2x3::IfcRampFlight::IfcRampFlight(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcRampFlight::IfcRampFlight(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcRampFlightType
::Ifc2x3::IfcRampFlightTypeEnum::Value Ifc2x3::IfcRampFlightType::PredefinedType() const {  return ::Ifc2x3::IfcRampFlightTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcRampFlightType::setPredefinedType(::Ifc2x3::IfcRampFlightTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcRampFlightTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcRampFlightType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[647]); }
const IfcParse::entity& Ifc2x3::IfcRampFlightType::Class() { return *((IfcParse::entity*)IFC2X3_types[647]); }
Ifc2x3::IfcRampFlightType::IfcRampFlightType(IfcEntityInstanceData&& e) : IfcBuildingElementType(std::move(e)) { }
Ifc2x3::IfcRampFlightType::IfcRampFlightType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcRampFlightTypeEnum::Value v10_PredefinedType) : IfcBuildingElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcRampFlightTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcRationalBezierCurve
std::vector< double > /*[2:?]*/ Ifc2x3::IfcRationalBezierCurve::WeightsData() const {  std::vector< double > /*[2:?]*/ v = get_attribute_value(5); return v; }
void Ifc2x3::IfcRationalBezierCurve::setWeightsData(std::vector< double > /*[2:?]*/ v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRationalBezierCurve::declaration() const { return *((IfcParse::entity*)IFC2X3_types[651]); }
const IfcParse::entity& Ifc2x3::IfcRationalBezierCurve::Class() { return *((IfcParse::entity*)IFC2X3_types[651]); }
Ifc2x3::IfcRationalBezierCurve::IfcRationalBezierCurve(IfcEntityInstanceData&& e) : IfcBezierCurve(std::move(e)) { }
Ifc2x3::IfcRationalBezierCurve::IfcRationalBezierCurve(int v1_Degree, aggregate_of< ::Ifc2x3::IfcCartesianPoint >::ptr v2_ControlPointsList, ::Ifc2x3::IfcBSplineCurveForm::Value v3_CurveForm, boost::logic::tribool v4_ClosedCurve, boost::logic::tribool v5_SelfIntersect, std::vector< double > /*[2:?]*/ v6_WeightsData) : IfcBezierCurve(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_Degree));set_attribute_value(1, (v2_ControlPointsList)->generalize());set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcBSplineCurveForm::Class(),(size_t)v3_CurveForm)));set_attribute_value(3, (v4_ClosedCurve));set_attribute_value(4, (v5_SelfIntersect));set_attribute_value(5, (v6_WeightsData));; populate_derived(); }

// Function implementations for IfcRectangleHollowProfileDef
double Ifc2x3::IfcRectangleHollowProfileDef::WallThickness() const {  double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcRectangleHollowProfileDef::setWallThickness(double v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
boost::optional< double > Ifc2x3::IfcRectangleHollowProfileDef::InnerFilletRadius() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcRectangleHollowProfileDef::setInnerFilletRadius(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
boost::optional< double > Ifc2x3::IfcRectangleHollowProfileDef::OuterFilletRadius() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcRectangleHollowProfileDef::setOuterFilletRadius(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }


const IfcParse::entity& Ifc2x3::IfcRectangleHollowProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[653]); }
const IfcParse::entity& Ifc2x3::IfcRectangleHollowProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[653]); }
Ifc2x3::IfcRectangleHollowProfileDef::IfcRectangleHollowProfileDef(IfcEntityInstanceData&& e) : IfcRectangleProfileDef(std::move(e)) { }
Ifc2x3::IfcRectangleHollowProfileDef::IfcRectangleHollowProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcAxis2Placement2D* v3_Position, double v4_XDim, double v5_YDim, double v6_WallThickness, boost::optional< double > v7_InnerFilletRadius, boost::optional< double > v8_OuterFilletRadius) : IfcRectangleProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_XDim));set_attribute_value(4, (v5_YDim));set_attribute_value(5, (v6_WallThickness)); if (v7_InnerFilletRadius) {set_attribute_value(6, (*v7_InnerFilletRadius)); } if (v8_OuterFilletRadius) {set_attribute_value(7, (*v8_OuterFilletRadius)); }; populate_derived(); }

// Function implementations for IfcRectangleProfileDef
double Ifc2x3::IfcRectangleProfileDef::XDim() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcRectangleProfileDef::setXDim(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
double Ifc2x3::IfcRectangleProfileDef::YDim() const {  double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcRectangleProfileDef::setYDim(double v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcRectangleProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[654]); }
const IfcParse::entity& Ifc2x3::IfcRectangleProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[654]); }
Ifc2x3::IfcRectangleProfileDef::IfcRectangleProfileDef(IfcEntityInstanceData&& e) : IfcParameterizedProfileDef(std::move(e)) { }
Ifc2x3::IfcRectangleProfileDef::IfcRectangleProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcAxis2Placement2D* v3_Position, double v4_XDim, double v5_YDim) : IfcParameterizedProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_XDim));set_attribute_value(4, (v5_YDim));; populate_derived(); }

// Function implementations for IfcRectangularPyramid
double Ifc2x3::IfcRectangularPyramid::XLength() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcRectangularPyramid::setXLength(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
double Ifc2x3::IfcRectangularPyramid::YLength() const {  double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcRectangularPyramid::setYLength(double v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
double Ifc2x3::IfcRectangularPyramid::Height() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcRectangularPyramid::setHeight(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcRectangularPyramid::declaration() const { return *((IfcParse::entity*)IFC2X3_types[655]); }
const IfcParse::entity& Ifc2x3::IfcRectangularPyramid::Class() { return *((IfcParse::entity*)IFC2X3_types[655]); }
Ifc2x3::IfcRectangularPyramid::IfcRectangularPyramid(IfcEntityInstanceData&& e) : IfcCsgPrimitive3D(std::move(e)) { }
Ifc2x3::IfcRectangularPyramid::IfcRectangularPyramid(::Ifc2x3::IfcAxis2Placement3D* v1_Position, double v2_XLength, double v3_YLength, double v4_Height) : IfcCsgPrimitive3D(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_Position ? v1_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_XLength));set_attribute_value(2, (v3_YLength));set_attribute_value(3, (v4_Height));; populate_derived(); }

// Function implementations for IfcRectangularTrimmedSurface
::Ifc2x3::IfcSurface* Ifc2x3::IfcRectangularTrimmedSurface::BasisSurface() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcSurface>(true); }
void Ifc2x3::IfcRectangularTrimmedSurface::setBasisSurface(::Ifc2x3::IfcSurface* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
double Ifc2x3::IfcRectangularTrimmedSurface::U1() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcRectangularTrimmedSurface::setU1(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
double Ifc2x3::IfcRectangularTrimmedSurface::V1() const {  double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcRectangularTrimmedSurface::setV1(double v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
double Ifc2x3::IfcRectangularTrimmedSurface::U2() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcRectangularTrimmedSurface::setU2(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
double Ifc2x3::IfcRectangularTrimmedSurface::V2() const {  double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcRectangularTrimmedSurface::setV2(double v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
bool Ifc2x3::IfcRectangularTrimmedSurface::Usense() const {  bool v = get_attribute_value(5); return v; }
void Ifc2x3::IfcRectangularTrimmedSurface::setUsense(bool v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
bool Ifc2x3::IfcRectangularTrimmedSurface::Vsense() const {  bool v = get_attribute_value(6); return v; }
void Ifc2x3::IfcRectangularTrimmedSurface::setVsense(bool v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcRectangularTrimmedSurface::declaration() const { return *((IfcParse::entity*)IFC2X3_types[656]); }
const IfcParse::entity& Ifc2x3::IfcRectangularTrimmedSurface::Class() { return *((IfcParse::entity*)IFC2X3_types[656]); }
Ifc2x3::IfcRectangularTrimmedSurface::IfcRectangularTrimmedSurface(IfcEntityInstanceData&& e) : IfcBoundedSurface(std::move(e)) { }
Ifc2x3::IfcRectangularTrimmedSurface::IfcRectangularTrimmedSurface(::Ifc2x3::IfcSurface* v1_BasisSurface, double v2_U1, double v3_V1, double v4_U2, double v5_V2, bool v6_Usense, bool v7_Vsense) : IfcBoundedSurface(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, v1_BasisSurface ? v1_BasisSurface->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_U1));set_attribute_value(2, (v3_V1));set_attribute_value(3, (v4_U2));set_attribute_value(4, (v5_V2));set_attribute_value(5, (v6_Usense));set_attribute_value(6, (v7_Vsense));; populate_derived(); }

// Function implementations for IfcReferencesValueDocument
::Ifc2x3::IfcDocumentSelect* Ifc2x3::IfcReferencesValueDocument::ReferencedDocument() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcDocumentSelect>(true); }
void Ifc2x3::IfcReferencesValueDocument::setReferencedDocument(::Ifc2x3::IfcDocumentSelect* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcAppliedValue >::ptr Ifc2x3::IfcReferencesValueDocument::ReferencingValues() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcAppliedValue >(); }
void Ifc2x3::IfcReferencesValueDocument::setReferencingValues(aggregate_of< ::Ifc2x3::IfcAppliedValue >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }
boost::optional< std::string > Ifc2x3::IfcReferencesValueDocument::Name() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcReferencesValueDocument::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< std::string > Ifc2x3::IfcReferencesValueDocument::Description() const { if(get_attribute_value(3).isNull()) { return boost::none; } std::string v = get_attribute_value(3); return v; }
void Ifc2x3::IfcReferencesValueDocument::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }


const IfcParse::entity& Ifc2x3::IfcReferencesValueDocument::declaration() const { return *((IfcParse::entity*)IFC2X3_types[657]); }
const IfcParse::entity& Ifc2x3::IfcReferencesValueDocument::Class() { return *((IfcParse::entity*)IFC2X3_types[657]); }
Ifc2x3::IfcReferencesValueDocument::IfcReferencesValueDocument(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcReferencesValueDocument::IfcReferencesValueDocument(::Ifc2x3::IfcDocumentSelect* v1_ReferencedDocument, aggregate_of< ::Ifc2x3::IfcAppliedValue >::ptr v2_ReferencingValues, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_ReferencedDocument ? v1_ReferencedDocument->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_ReferencingValues)->generalize()); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }; populate_derived(); }

// Function implementations for IfcRegularTimeSeries
double Ifc2x3::IfcRegularTimeSeries::TimeStep() const {  double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcRegularTimeSeries::setTimeStep(double v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
aggregate_of< ::Ifc2x3::IfcTimeSeriesValue >::ptr Ifc2x3::IfcRegularTimeSeries::Values() const {  aggregate_of_instance::ptr es = get_attribute_value(9); return es->as< ::Ifc2x3::IfcTimeSeriesValue >(); }
void Ifc2x3::IfcRegularTimeSeries::setValues(aggregate_of< ::Ifc2x3::IfcTimeSeriesValue >::ptr v) { set_attribute_value(9, (v)->generalize());if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcRegularTimeSeries::declaration() const { return *((IfcParse::entity*)IFC2X3_types[659]); }
const IfcParse::entity& Ifc2x3::IfcRegularTimeSeries::Class() { return *((IfcParse::entity*)IFC2X3_types[659]); }
Ifc2x3::IfcRegularTimeSeries::IfcRegularTimeSeries(IfcEntityInstanceData&& e) : IfcTimeSeries(std::move(e)) { }
Ifc2x3::IfcRegularTimeSeries::IfcRegularTimeSeries(std::string v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcDateTimeSelect* v3_StartTime, ::Ifc2x3::IfcDateTimeSelect* v4_EndTime, ::Ifc2x3::IfcTimeSeriesDataTypeEnum::Value v5_TimeSeriesDataType, ::Ifc2x3::IfcDataOriginEnum::Value v6_DataOrigin, boost::optional< std::string > v7_UserDefinedDataOrigin, ::Ifc2x3::IfcUnit* v8_Unit, double v9_TimeStep, aggregate_of< ::Ifc2x3::IfcTimeSeriesValue >::ptr v10_Values) : IfcTimeSeries(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_StartTime ? v3_StartTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_EndTime ? v4_EndTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(4, (EnumerationReference(&::Ifc2x3::IfcTimeSeriesDataTypeEnum::Class(),(size_t)v5_TimeSeriesDataType)));set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcDataOriginEnum::Class(),(size_t)v6_DataOrigin))); if (v7_UserDefinedDataOrigin) {set_attribute_value(6, (*v7_UserDefinedDataOrigin)); }set_attribute_value(7, v8_Unit ? v8_Unit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(8, (v9_TimeStep));set_attribute_value(9, (v10_Values)->generalize());; populate_derived(); }

// Function implementations for IfcReinforcementBarProperties
double Ifc2x3::IfcReinforcementBarProperties::TotalCrossSectionArea() const {  double v = get_attribute_value(0); return v; }
void Ifc2x3::IfcReinforcementBarProperties::setTotalCrossSectionArea(double v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
std::string Ifc2x3::IfcReinforcementBarProperties::SteelGrade() const {  std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcReinforcementBarProperties::setSteelGrade(std::string v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
boost::optional< ::Ifc2x3::IfcReinforcingBarSurfaceEnum::Value > Ifc2x3::IfcReinforcementBarProperties::BarSurface() const { if(get_attribute_value(2).isNull()) { return boost::none; } return ::Ifc2x3::IfcReinforcingBarSurfaceEnum::FromString(get_attribute_value(2)); }
void Ifc2x3::IfcReinforcementBarProperties::setBarSurface(boost::optional< ::Ifc2x3::IfcReinforcingBarSurfaceEnum::Value > v) { if (v) {set_attribute_value(2, EnumerationReference(&::Ifc2x3::IfcReinforcingBarSurfaceEnum::Class(), (size_t) *v));} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcReinforcementBarProperties::EffectiveDepth() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcReinforcementBarProperties::setEffectiveDepth(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< double > Ifc2x3::IfcReinforcementBarProperties::NominalBarDiameter() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcReinforcementBarProperties::setNominalBarDiameter(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< double > Ifc2x3::IfcReinforcementBarProperties::BarCount() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcReinforcementBarProperties::setBarCount(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }


const IfcParse::entity& Ifc2x3::IfcReinforcementBarProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[660]); }
const IfcParse::entity& Ifc2x3::IfcReinforcementBarProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[660]); }
Ifc2x3::IfcReinforcementBarProperties::IfcReinforcementBarProperties(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcReinforcementBarProperties::IfcReinforcementBarProperties(double v1_TotalCrossSectionArea, std::string v2_SteelGrade, boost::optional< ::Ifc2x3::IfcReinforcingBarSurfaceEnum::Value > v3_BarSurface, boost::optional< double > v4_EffectiveDepth, boost::optional< double > v5_NominalBarDiameter, boost::optional< double > v6_BarCount) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_TotalCrossSectionArea));set_attribute_value(1, (v2_SteelGrade)); if (v3_BarSurface) {set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcReinforcingBarSurfaceEnum::Class(),(size_t)*v3_BarSurface))); } if (v4_EffectiveDepth) {set_attribute_value(3, (*v4_EffectiveDepth)); } if (v5_NominalBarDiameter) {set_attribute_value(4, (*v5_NominalBarDiameter)); } if (v6_BarCount) {set_attribute_value(5, (*v6_BarCount)); }; populate_derived(); }

// Function implementations for IfcReinforcementDefinitionProperties
boost::optional< std::string > Ifc2x3::IfcReinforcementDefinitionProperties::DefinitionType() const { if(get_attribute_value(4).isNull()) { return boost::none; } std::string v = get_attribute_value(4); return v; }
void Ifc2x3::IfcReinforcementDefinitionProperties::setDefinitionType(boost::optional< std::string > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
aggregate_of< ::Ifc2x3::IfcSectionReinforcementProperties >::ptr Ifc2x3::IfcReinforcementDefinitionProperties::ReinforcementSectionDefinitions() const {  aggregate_of_instance::ptr es = get_attribute_value(5); return es->as< ::Ifc2x3::IfcSectionReinforcementProperties >(); }
void Ifc2x3::IfcReinforcementDefinitionProperties::setReinforcementSectionDefinitions(aggregate_of< ::Ifc2x3::IfcSectionReinforcementProperties >::ptr v) { set_attribute_value(5, (v)->generalize());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcReinforcementDefinitionProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[661]); }
const IfcParse::entity& Ifc2x3::IfcReinforcementDefinitionProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[661]); }
Ifc2x3::IfcReinforcementDefinitionProperties::IfcReinforcementDefinitionProperties(IfcEntityInstanceData&& e) : IfcPropertySetDefinition(std::move(e)) { }
Ifc2x3::IfcReinforcementDefinitionProperties::IfcReinforcementDefinitionProperties(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_DefinitionType, aggregate_of< ::Ifc2x3::IfcSectionReinforcementProperties >::ptr v6_ReinforcementSectionDefinitions) : IfcPropertySetDefinition(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_DefinitionType) {set_attribute_value(4, (*v5_DefinitionType)); }set_attribute_value(5, (v6_ReinforcementSectionDefinitions)->generalize());; populate_derived(); }

// Function implementations for IfcReinforcingBar
double Ifc2x3::IfcReinforcingBar::NominalDiameter() const {  double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcReinforcingBar::setNominalDiameter(double v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }
double Ifc2x3::IfcReinforcingBar::CrossSectionArea() const {  double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcReinforcingBar::setCrossSectionArea(double v) { set_attribute_value(10, v);if constexpr (false)unset_attribute_value(10); }
boost::optional< double > Ifc2x3::IfcReinforcingBar::BarLength() const { if(get_attribute_value(11).isNull()) { return boost::none; } double v = get_attribute_value(11); return v; }
void Ifc2x3::IfcReinforcingBar::setBarLength(boost::optional< double > v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
::Ifc2x3::IfcReinforcingBarRoleEnum::Value Ifc2x3::IfcReinforcingBar::BarRole() const {  return ::Ifc2x3::IfcReinforcingBarRoleEnum::FromString(get_attribute_value(12)); }
void Ifc2x3::IfcReinforcingBar::setBarRole(::Ifc2x3::IfcReinforcingBarRoleEnum::Value v) { set_attribute_value(12, EnumerationReference(&::Ifc2x3::IfcReinforcingBarRoleEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(12); }
boost::optional< ::Ifc2x3::IfcReinforcingBarSurfaceEnum::Value > Ifc2x3::IfcReinforcingBar::BarSurface() const { if(get_attribute_value(13).isNull()) { return boost::none; } return ::Ifc2x3::IfcReinforcingBarSurfaceEnum::FromString(get_attribute_value(13)); }
void Ifc2x3::IfcReinforcingBar::setBarSurface(boost::optional< ::Ifc2x3::IfcReinforcingBarSurfaceEnum::Value > v) { if (v) {set_attribute_value(13, EnumerationReference(&::Ifc2x3::IfcReinforcingBarSurfaceEnum::Class(), (size_t) *v));} else {unset_attribute_value(13);} }


const IfcParse::entity& Ifc2x3::IfcReinforcingBar::declaration() const { return *((IfcParse::entity*)IFC2X3_types[662]); }
const IfcParse::entity& Ifc2x3::IfcReinforcingBar::Class() { return *((IfcParse::entity*)IFC2X3_types[662]); }
Ifc2x3::IfcReinforcingBar::IfcReinforcingBar(IfcEntityInstanceData&& e) : IfcReinforcingElement(std::move(e)) { }
Ifc2x3::IfcReinforcingBar::IfcReinforcingBar(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade, double v10_NominalDiameter, double v11_CrossSectionArea, boost::optional< double > v12_BarLength, ::Ifc2x3::IfcReinforcingBarRoleEnum::Value v13_BarRole, boost::optional< ::Ifc2x3::IfcReinforcingBarSurfaceEnum::Value > v14_BarSurface) : IfcReinforcingElement(IfcEntityInstanceData(in_memory_attribute_storage(14))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_SteelGrade) {set_attribute_value(8, (*v9_SteelGrade)); }set_attribute_value(9, (v10_NominalDiameter));set_attribute_value(10, (v11_CrossSectionArea)); if (v12_BarLength) {set_attribute_value(11, (*v12_BarLength)); }set_attribute_value(12, (EnumerationReference(&::Ifc2x3::IfcReinforcingBarRoleEnum::Class(),(size_t)v13_BarRole))); if (v14_BarSurface) {set_attribute_value(13, (EnumerationReference(&::Ifc2x3::IfcReinforcingBarSurfaceEnum::Class(),(size_t)*v14_BarSurface))); }; populate_derived(); }

// Function implementations for IfcReinforcingElement
boost::optional< std::string > Ifc2x3::IfcReinforcingElement::SteelGrade() const { if(get_attribute_value(8).isNull()) { return boost::none; } std::string v = get_attribute_value(8); return v; }
void Ifc2x3::IfcReinforcingElement::setSteelGrade(boost::optional< std::string > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }


const IfcParse::entity& Ifc2x3::IfcReinforcingElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[665]); }
const IfcParse::entity& Ifc2x3::IfcReinforcingElement::Class() { return *((IfcParse::entity*)IFC2X3_types[665]); }
Ifc2x3::IfcReinforcingElement::IfcReinforcingElement(IfcEntityInstanceData&& e) : IfcBuildingElementComponent(std::move(e)) { }
Ifc2x3::IfcReinforcingElement::IfcReinforcingElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade) : IfcBuildingElementComponent(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_SteelGrade) {set_attribute_value(8, (*v9_SteelGrade)); }; populate_derived(); }

// Function implementations for IfcReinforcingMesh
boost::optional< double > Ifc2x3::IfcReinforcingMesh::MeshLength() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcReinforcingMesh::setMeshLength(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
boost::optional< double > Ifc2x3::IfcReinforcingMesh::MeshWidth() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcReinforcingMesh::setMeshWidth(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
double Ifc2x3::IfcReinforcingMesh::LongitudinalBarNominalDiameter() const {  double v = get_attribute_value(11); return v; }
void Ifc2x3::IfcReinforcingMesh::setLongitudinalBarNominalDiameter(double v) { set_attribute_value(11, v);if constexpr (false)unset_attribute_value(11); }
double Ifc2x3::IfcReinforcingMesh::TransverseBarNominalDiameter() const {  double v = get_attribute_value(12); return v; }
void Ifc2x3::IfcReinforcingMesh::setTransverseBarNominalDiameter(double v) { set_attribute_value(12, v);if constexpr (false)unset_attribute_value(12); }
double Ifc2x3::IfcReinforcingMesh::LongitudinalBarCrossSectionArea() const {  double v = get_attribute_value(13); return v; }
void Ifc2x3::IfcReinforcingMesh::setLongitudinalBarCrossSectionArea(double v) { set_attribute_value(13, v);if constexpr (false)unset_attribute_value(13); }
double Ifc2x3::IfcReinforcingMesh::TransverseBarCrossSectionArea() const {  double v = get_attribute_value(14); return v; }
void Ifc2x3::IfcReinforcingMesh::setTransverseBarCrossSectionArea(double v) { set_attribute_value(14, v);if constexpr (false)unset_attribute_value(14); }
double Ifc2x3::IfcReinforcingMesh::LongitudinalBarSpacing() const {  double v = get_attribute_value(15); return v; }
void Ifc2x3::IfcReinforcingMesh::setLongitudinalBarSpacing(double v) { set_attribute_value(15, v);if constexpr (false)unset_attribute_value(15); }
double Ifc2x3::IfcReinforcingMesh::TransverseBarSpacing() const {  double v = get_attribute_value(16); return v; }
void Ifc2x3::IfcReinforcingMesh::setTransverseBarSpacing(double v) { set_attribute_value(16, v);if constexpr (false)unset_attribute_value(16); }


const IfcParse::entity& Ifc2x3::IfcReinforcingMesh::declaration() const { return *((IfcParse::entity*)IFC2X3_types[666]); }
const IfcParse::entity& Ifc2x3::IfcReinforcingMesh::Class() { return *((IfcParse::entity*)IFC2X3_types[666]); }
Ifc2x3::IfcReinforcingMesh::IfcReinforcingMesh(IfcEntityInstanceData&& e) : IfcReinforcingElement(std::move(e)) { }
Ifc2x3::IfcReinforcingMesh::IfcReinforcingMesh(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade, boost::optional< double > v10_MeshLength, boost::optional< double > v11_MeshWidth, double v12_LongitudinalBarNominalDiameter, double v13_TransverseBarNominalDiameter, double v14_LongitudinalBarCrossSectionArea, double v15_TransverseBarCrossSectionArea, double v16_LongitudinalBarSpacing, double v17_TransverseBarSpacing) : IfcReinforcingElement(IfcEntityInstanceData(in_memory_attribute_storage(17))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_SteelGrade) {set_attribute_value(8, (*v9_SteelGrade)); } if (v10_MeshLength) {set_attribute_value(9, (*v10_MeshLength)); } if (v11_MeshWidth) {set_attribute_value(10, (*v11_MeshWidth)); }set_attribute_value(11, (v12_LongitudinalBarNominalDiameter));set_attribute_value(12, (v13_TransverseBarNominalDiameter));set_attribute_value(13, (v14_LongitudinalBarCrossSectionArea));set_attribute_value(14, (v15_TransverseBarCrossSectionArea));set_attribute_value(15, (v16_LongitudinalBarSpacing));set_attribute_value(16, (v17_TransverseBarSpacing));; populate_derived(); }

// Function implementations for IfcRelAggregates


const IfcParse::entity& Ifc2x3::IfcRelAggregates::declaration() const { return *((IfcParse::entity*)IFC2X3_types[667]); }
const IfcParse::entity& Ifc2x3::IfcRelAggregates::Class() { return *((IfcParse::entity*)IFC2X3_types[667]); }
Ifc2x3::IfcRelAggregates::IfcRelAggregates(IfcEntityInstanceData&& e) : IfcRelDecomposes(std::move(e)) { }
Ifc2x3::IfcRelAggregates::IfcRelAggregates(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcObjectDefinition* v5_RelatingObject, aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr v6_RelatedObjects) : IfcRelDecomposes(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_RelatingObject ? v5_RelatingObject->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, (v6_RelatedObjects)->generalize());; populate_derived(); }

// Function implementations for IfcRelAssigns
aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr Ifc2x3::IfcRelAssigns::RelatedObjects() const {  aggregate_of_instance::ptr es = get_attribute_value(4); return es->as< ::Ifc2x3::IfcObjectDefinition >(); }
void Ifc2x3::IfcRelAssigns::setRelatedObjects(aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr v) { set_attribute_value(4, (v)->generalize());if constexpr (false)unset_attribute_value(4); }
boost::optional< ::Ifc2x3::IfcObjectTypeEnum::Value > Ifc2x3::IfcRelAssigns::RelatedObjectsType() const { if(get_attribute_value(5).isNull()) { return boost::none; } return ::Ifc2x3::IfcObjectTypeEnum::FromString(get_attribute_value(5)); }
void Ifc2x3::IfcRelAssigns::setRelatedObjectsType(boost::optional< ::Ifc2x3::IfcObjectTypeEnum::Value > v) { if (v) {set_attribute_value(5, EnumerationReference(&::Ifc2x3::IfcObjectTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(5);} }


const IfcParse::entity& Ifc2x3::IfcRelAssigns::declaration() const { return *((IfcParse::entity*)IFC2X3_types[668]); }
const IfcParse::entity& Ifc2x3::IfcRelAssigns::Class() { return *((IfcParse::entity*)IFC2X3_types[668]); }
Ifc2x3::IfcRelAssigns::IfcRelAssigns(IfcEntityInstanceData&& e) : IfcRelationship(std::move(e)) { }
Ifc2x3::IfcRelAssigns::IfcRelAssigns(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< ::Ifc2x3::IfcObjectTypeEnum::Value > v6_RelatedObjectsType) : IfcRelationship(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }; populate_derived(); }

// Function implementations for IfcRelAssignsTasks
::Ifc2x3::IfcScheduleTimeControl* Ifc2x3::IfcRelAssignsTasks::TimeForTask() const { if(get_attribute_value(7).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(7)))->as<::Ifc2x3::IfcScheduleTimeControl>(true); }
void Ifc2x3::IfcRelAssignsTasks::setTimeForTask(::Ifc2x3::IfcScheduleTimeControl* v) { set_attribute_value(7, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(7); }


const IfcParse::entity& Ifc2x3::IfcRelAssignsTasks::declaration() const { return *((IfcParse::entity*)IFC2X3_types[669]); }
const IfcParse::entity& Ifc2x3::IfcRelAssignsTasks::Class() { return *((IfcParse::entity*)IFC2X3_types[669]); }
Ifc2x3::IfcRelAssignsTasks::IfcRelAssignsTasks(IfcEntityInstanceData&& e) : IfcRelAssignsToControl(std::move(e)) { }
Ifc2x3::IfcRelAssignsTasks::IfcRelAssignsTasks(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< ::Ifc2x3::IfcObjectTypeEnum::Value > v6_RelatedObjectsType, ::Ifc2x3::IfcControl* v7_RelatingControl, ::Ifc2x3::IfcScheduleTimeControl* v8_TimeForTask) : IfcRelAssignsToControl(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }set_attribute_value(6, v7_RelatingControl ? v7_RelatingControl->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_TimeForTask ? v8_TimeForTask->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelAssignsToActor
::Ifc2x3::IfcActor* Ifc2x3::IfcRelAssignsToActor::RelatingActor() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcActor>(true); }
void Ifc2x3::IfcRelAssignsToActor::setRelatingActor(::Ifc2x3::IfcActor* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
::Ifc2x3::IfcActorRole* Ifc2x3::IfcRelAssignsToActor::ActingRole() const { if(get_attribute_value(7).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(7)))->as<::Ifc2x3::IfcActorRole>(true); }
void Ifc2x3::IfcRelAssignsToActor::setActingRole(::Ifc2x3::IfcActorRole* v) { set_attribute_value(7, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(7); }


const IfcParse::entity& Ifc2x3::IfcRelAssignsToActor::declaration() const { return *((IfcParse::entity*)IFC2X3_types[670]); }
const IfcParse::entity& Ifc2x3::IfcRelAssignsToActor::Class() { return *((IfcParse::entity*)IFC2X3_types[670]); }
Ifc2x3::IfcRelAssignsToActor::IfcRelAssignsToActor(IfcEntityInstanceData&& e) : IfcRelAssigns(std::move(e)) { }
Ifc2x3::IfcRelAssignsToActor::IfcRelAssignsToActor(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< ::Ifc2x3::IfcObjectTypeEnum::Value > v6_RelatedObjectsType, ::Ifc2x3::IfcActor* v7_RelatingActor, ::Ifc2x3::IfcActorRole* v8_ActingRole) : IfcRelAssigns(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }set_attribute_value(6, v7_RelatingActor ? v7_RelatingActor->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_ActingRole ? v8_ActingRole->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelAssignsToControl
::Ifc2x3::IfcControl* Ifc2x3::IfcRelAssignsToControl::RelatingControl() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcControl>(true); }
void Ifc2x3::IfcRelAssignsToControl::setRelatingControl(::Ifc2x3::IfcControl* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcRelAssignsToControl::declaration() const { return *((IfcParse::entity*)IFC2X3_types[671]); }
const IfcParse::entity& Ifc2x3::IfcRelAssignsToControl::Class() { return *((IfcParse::entity*)IFC2X3_types[671]); }
Ifc2x3::IfcRelAssignsToControl::IfcRelAssignsToControl(IfcEntityInstanceData&& e) : IfcRelAssigns(std::move(e)) { }
Ifc2x3::IfcRelAssignsToControl::IfcRelAssignsToControl(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< ::Ifc2x3::IfcObjectTypeEnum::Value > v6_RelatedObjectsType, ::Ifc2x3::IfcControl* v7_RelatingControl) : IfcRelAssigns(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }set_attribute_value(6, v7_RelatingControl ? v7_RelatingControl->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelAssignsToGroup
::Ifc2x3::IfcGroup* Ifc2x3::IfcRelAssignsToGroup::RelatingGroup() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcGroup>(true); }
void Ifc2x3::IfcRelAssignsToGroup::setRelatingGroup(::Ifc2x3::IfcGroup* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcRelAssignsToGroup::declaration() const { return *((IfcParse::entity*)IFC2X3_types[672]); }
const IfcParse::entity& Ifc2x3::IfcRelAssignsToGroup::Class() { return *((IfcParse::entity*)IFC2X3_types[672]); }
Ifc2x3::IfcRelAssignsToGroup::IfcRelAssignsToGroup(IfcEntityInstanceData&& e) : IfcRelAssigns(std::move(e)) { }
Ifc2x3::IfcRelAssignsToGroup::IfcRelAssignsToGroup(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< ::Ifc2x3::IfcObjectTypeEnum::Value > v6_RelatedObjectsType, ::Ifc2x3::IfcGroup* v7_RelatingGroup) : IfcRelAssigns(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }set_attribute_value(6, v7_RelatingGroup ? v7_RelatingGroup->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelAssignsToProcess
::Ifc2x3::IfcProcess* Ifc2x3::IfcRelAssignsToProcess::RelatingProcess() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcProcess>(true); }
void Ifc2x3::IfcRelAssignsToProcess::setRelatingProcess(::Ifc2x3::IfcProcess* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
::Ifc2x3::IfcMeasureWithUnit* Ifc2x3::IfcRelAssignsToProcess::QuantityInProcess() const { if(get_attribute_value(7).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(7)))->as<::Ifc2x3::IfcMeasureWithUnit>(true); }
void Ifc2x3::IfcRelAssignsToProcess::setQuantityInProcess(::Ifc2x3::IfcMeasureWithUnit* v) { set_attribute_value(7, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(7); }


const IfcParse::entity& Ifc2x3::IfcRelAssignsToProcess::declaration() const { return *((IfcParse::entity*)IFC2X3_types[673]); }
const IfcParse::entity& Ifc2x3::IfcRelAssignsToProcess::Class() { return *((IfcParse::entity*)IFC2X3_types[673]); }
Ifc2x3::IfcRelAssignsToProcess::IfcRelAssignsToProcess(IfcEntityInstanceData&& e) : IfcRelAssigns(std::move(e)) { }
Ifc2x3::IfcRelAssignsToProcess::IfcRelAssignsToProcess(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< ::Ifc2x3::IfcObjectTypeEnum::Value > v6_RelatedObjectsType, ::Ifc2x3::IfcProcess* v7_RelatingProcess, ::Ifc2x3::IfcMeasureWithUnit* v8_QuantityInProcess) : IfcRelAssigns(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }set_attribute_value(6, v7_RelatingProcess ? v7_RelatingProcess->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_QuantityInProcess ? v8_QuantityInProcess->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelAssignsToProduct
::Ifc2x3::IfcProduct* Ifc2x3::IfcRelAssignsToProduct::RelatingProduct() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcProduct>(true); }
void Ifc2x3::IfcRelAssignsToProduct::setRelatingProduct(::Ifc2x3::IfcProduct* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcRelAssignsToProduct::declaration() const { return *((IfcParse::entity*)IFC2X3_types[674]); }
const IfcParse::entity& Ifc2x3::IfcRelAssignsToProduct::Class() { return *((IfcParse::entity*)IFC2X3_types[674]); }
Ifc2x3::IfcRelAssignsToProduct::IfcRelAssignsToProduct(IfcEntityInstanceData&& e) : IfcRelAssigns(std::move(e)) { }
Ifc2x3::IfcRelAssignsToProduct::IfcRelAssignsToProduct(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< ::Ifc2x3::IfcObjectTypeEnum::Value > v6_RelatedObjectsType, ::Ifc2x3::IfcProduct* v7_RelatingProduct) : IfcRelAssigns(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }set_attribute_value(6, v7_RelatingProduct ? v7_RelatingProduct->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelAssignsToProjectOrder


const IfcParse::entity& Ifc2x3::IfcRelAssignsToProjectOrder::declaration() const { return *((IfcParse::entity*)IFC2X3_types[675]); }
const IfcParse::entity& Ifc2x3::IfcRelAssignsToProjectOrder::Class() { return *((IfcParse::entity*)IFC2X3_types[675]); }
Ifc2x3::IfcRelAssignsToProjectOrder::IfcRelAssignsToProjectOrder(IfcEntityInstanceData&& e) : IfcRelAssignsToControl(std::move(e)) { }
Ifc2x3::IfcRelAssignsToProjectOrder::IfcRelAssignsToProjectOrder(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< ::Ifc2x3::IfcObjectTypeEnum::Value > v6_RelatedObjectsType, ::Ifc2x3::IfcControl* v7_RelatingControl) : IfcRelAssignsToControl(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }set_attribute_value(6, v7_RelatingControl ? v7_RelatingControl->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelAssignsToResource
::Ifc2x3::IfcResource* Ifc2x3::IfcRelAssignsToResource::RelatingResource() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcResource>(true); }
void Ifc2x3::IfcRelAssignsToResource::setRelatingResource(::Ifc2x3::IfcResource* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcRelAssignsToResource::declaration() const { return *((IfcParse::entity*)IFC2X3_types[676]); }
const IfcParse::entity& Ifc2x3::IfcRelAssignsToResource::Class() { return *((IfcParse::entity*)IFC2X3_types[676]); }
Ifc2x3::IfcRelAssignsToResource::IfcRelAssignsToResource(IfcEntityInstanceData&& e) : IfcRelAssigns(std::move(e)) { }
Ifc2x3::IfcRelAssignsToResource::IfcRelAssignsToResource(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< ::Ifc2x3::IfcObjectTypeEnum::Value > v6_RelatedObjectsType, ::Ifc2x3::IfcResource* v7_RelatingResource) : IfcRelAssigns(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }set_attribute_value(6, v7_RelatingResource ? v7_RelatingResource->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelAssociates
aggregate_of< ::Ifc2x3::IfcRoot >::ptr Ifc2x3::IfcRelAssociates::RelatedObjects() const {  aggregate_of_instance::ptr es = get_attribute_value(4); return es->as< ::Ifc2x3::IfcRoot >(); }
void Ifc2x3::IfcRelAssociates::setRelatedObjects(aggregate_of< ::Ifc2x3::IfcRoot >::ptr v) { set_attribute_value(4, (v)->generalize());if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcRelAssociates::declaration() const { return *((IfcParse::entity*)IFC2X3_types[677]); }
const IfcParse::entity& Ifc2x3::IfcRelAssociates::Class() { return *((IfcParse::entity*)IFC2X3_types[677]); }
Ifc2x3::IfcRelAssociates::IfcRelAssociates(IfcEntityInstanceData&& e) : IfcRelationship(std::move(e)) { }
Ifc2x3::IfcRelAssociates::IfcRelAssociates(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcRoot >::ptr v5_RelatedObjects) : IfcRelationship(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize());; populate_derived(); }

// Function implementations for IfcRelAssociatesAppliedValue
::Ifc2x3::IfcAppliedValue* Ifc2x3::IfcRelAssociatesAppliedValue::RelatingAppliedValue() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcAppliedValue>(true); }
void Ifc2x3::IfcRelAssociatesAppliedValue::setRelatingAppliedValue(::Ifc2x3::IfcAppliedValue* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelAssociatesAppliedValue::declaration() const { return *((IfcParse::entity*)IFC2X3_types[678]); }
const IfcParse::entity& Ifc2x3::IfcRelAssociatesAppliedValue::Class() { return *((IfcParse::entity*)IFC2X3_types[678]); }
Ifc2x3::IfcRelAssociatesAppliedValue::IfcRelAssociatesAppliedValue(IfcEntityInstanceData&& e) : IfcRelAssociates(std::move(e)) { }
Ifc2x3::IfcRelAssociatesAppliedValue::IfcRelAssociatesAppliedValue(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcRoot >::ptr v5_RelatedObjects, ::Ifc2x3::IfcAppliedValue* v6_RelatingAppliedValue) : IfcRelAssociates(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize());set_attribute_value(5, v6_RelatingAppliedValue ? v6_RelatingAppliedValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelAssociatesApproval
::Ifc2x3::IfcApproval* Ifc2x3::IfcRelAssociatesApproval::RelatingApproval() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcApproval>(true); }
void Ifc2x3::IfcRelAssociatesApproval::setRelatingApproval(::Ifc2x3::IfcApproval* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelAssociatesApproval::declaration() const { return *((IfcParse::entity*)IFC2X3_types[679]); }
const IfcParse::entity& Ifc2x3::IfcRelAssociatesApproval::Class() { return *((IfcParse::entity*)IFC2X3_types[679]); }
Ifc2x3::IfcRelAssociatesApproval::IfcRelAssociatesApproval(IfcEntityInstanceData&& e) : IfcRelAssociates(std::move(e)) { }
Ifc2x3::IfcRelAssociatesApproval::IfcRelAssociatesApproval(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcRoot >::ptr v5_RelatedObjects, ::Ifc2x3::IfcApproval* v6_RelatingApproval) : IfcRelAssociates(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize());set_attribute_value(5, v6_RelatingApproval ? v6_RelatingApproval->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelAssociatesClassification
::Ifc2x3::IfcClassificationNotationSelect* Ifc2x3::IfcRelAssociatesClassification::RelatingClassification() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcClassificationNotationSelect>(true); }
void Ifc2x3::IfcRelAssociatesClassification::setRelatingClassification(::Ifc2x3::IfcClassificationNotationSelect* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelAssociatesClassification::declaration() const { return *((IfcParse::entity*)IFC2X3_types[680]); }
const IfcParse::entity& Ifc2x3::IfcRelAssociatesClassification::Class() { return *((IfcParse::entity*)IFC2X3_types[680]); }
Ifc2x3::IfcRelAssociatesClassification::IfcRelAssociatesClassification(IfcEntityInstanceData&& e) : IfcRelAssociates(std::move(e)) { }
Ifc2x3::IfcRelAssociatesClassification::IfcRelAssociatesClassification(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcRoot >::ptr v5_RelatedObjects, ::Ifc2x3::IfcClassificationNotationSelect* v6_RelatingClassification) : IfcRelAssociates(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize());set_attribute_value(5, v6_RelatingClassification ? v6_RelatingClassification->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelAssociatesConstraint
std::string Ifc2x3::IfcRelAssociatesConstraint::Intent() const {  std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcRelAssociatesConstraint::setIntent(std::string v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcConstraint* Ifc2x3::IfcRelAssociatesConstraint::RelatingConstraint() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcConstraint>(true); }
void Ifc2x3::IfcRelAssociatesConstraint::setRelatingConstraint(::Ifc2x3::IfcConstraint* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcRelAssociatesConstraint::declaration() const { return *((IfcParse::entity*)IFC2X3_types[681]); }
const IfcParse::entity& Ifc2x3::IfcRelAssociatesConstraint::Class() { return *((IfcParse::entity*)IFC2X3_types[681]); }
Ifc2x3::IfcRelAssociatesConstraint::IfcRelAssociatesConstraint(IfcEntityInstanceData&& e) : IfcRelAssociates(std::move(e)) { }
Ifc2x3::IfcRelAssociatesConstraint::IfcRelAssociatesConstraint(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcRoot >::ptr v5_RelatedObjects, std::string v6_Intent, ::Ifc2x3::IfcConstraint* v7_RelatingConstraint) : IfcRelAssociates(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize());set_attribute_value(5, (v6_Intent));set_attribute_value(6, v7_RelatingConstraint ? v7_RelatingConstraint->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelAssociatesDocument
::Ifc2x3::IfcDocumentSelect* Ifc2x3::IfcRelAssociatesDocument::RelatingDocument() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcDocumentSelect>(true); }
void Ifc2x3::IfcRelAssociatesDocument::setRelatingDocument(::Ifc2x3::IfcDocumentSelect* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelAssociatesDocument::declaration() const { return *((IfcParse::entity*)IFC2X3_types[682]); }
const IfcParse::entity& Ifc2x3::IfcRelAssociatesDocument::Class() { return *((IfcParse::entity*)IFC2X3_types[682]); }
Ifc2x3::IfcRelAssociatesDocument::IfcRelAssociatesDocument(IfcEntityInstanceData&& e) : IfcRelAssociates(std::move(e)) { }
Ifc2x3::IfcRelAssociatesDocument::IfcRelAssociatesDocument(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcRoot >::ptr v5_RelatedObjects, ::Ifc2x3::IfcDocumentSelect* v6_RelatingDocument) : IfcRelAssociates(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize());set_attribute_value(5, v6_RelatingDocument ? v6_RelatingDocument->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelAssociatesLibrary
::Ifc2x3::IfcLibrarySelect* Ifc2x3::IfcRelAssociatesLibrary::RelatingLibrary() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcLibrarySelect>(true); }
void Ifc2x3::IfcRelAssociatesLibrary::setRelatingLibrary(::Ifc2x3::IfcLibrarySelect* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelAssociatesLibrary::declaration() const { return *((IfcParse::entity*)IFC2X3_types[683]); }
const IfcParse::entity& Ifc2x3::IfcRelAssociatesLibrary::Class() { return *((IfcParse::entity*)IFC2X3_types[683]); }
Ifc2x3::IfcRelAssociatesLibrary::IfcRelAssociatesLibrary(IfcEntityInstanceData&& e) : IfcRelAssociates(std::move(e)) { }
Ifc2x3::IfcRelAssociatesLibrary::IfcRelAssociatesLibrary(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcRoot >::ptr v5_RelatedObjects, ::Ifc2x3::IfcLibrarySelect* v6_RelatingLibrary) : IfcRelAssociates(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize());set_attribute_value(5, v6_RelatingLibrary ? v6_RelatingLibrary->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelAssociatesMaterial
::Ifc2x3::IfcMaterialSelect* Ifc2x3::IfcRelAssociatesMaterial::RelatingMaterial() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcMaterialSelect>(true); }
void Ifc2x3::IfcRelAssociatesMaterial::setRelatingMaterial(::Ifc2x3::IfcMaterialSelect* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelAssociatesMaterial::declaration() const { return *((IfcParse::entity*)IFC2X3_types[684]); }
const IfcParse::entity& Ifc2x3::IfcRelAssociatesMaterial::Class() { return *((IfcParse::entity*)IFC2X3_types[684]); }
Ifc2x3::IfcRelAssociatesMaterial::IfcRelAssociatesMaterial(IfcEntityInstanceData&& e) : IfcRelAssociates(std::move(e)) { }
Ifc2x3::IfcRelAssociatesMaterial::IfcRelAssociatesMaterial(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcRoot >::ptr v5_RelatedObjects, ::Ifc2x3::IfcMaterialSelect* v6_RelatingMaterial) : IfcRelAssociates(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize());set_attribute_value(5, v6_RelatingMaterial ? v6_RelatingMaterial->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelAssociatesProfileProperties
::Ifc2x3::IfcProfileProperties* Ifc2x3::IfcRelAssociatesProfileProperties::RelatingProfileProperties() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcProfileProperties>(true); }
void Ifc2x3::IfcRelAssociatesProfileProperties::setRelatingProfileProperties(::Ifc2x3::IfcProfileProperties* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcShapeAspect* Ifc2x3::IfcRelAssociatesProfileProperties::ProfileSectionLocation() const { if(get_attribute_value(6).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcShapeAspect>(true); }
void Ifc2x3::IfcRelAssociatesProfileProperties::setProfileSectionLocation(::Ifc2x3::IfcShapeAspect* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
::Ifc2x3::IfcOrientationSelect* Ifc2x3::IfcRelAssociatesProfileProperties::ProfileOrientation() const { if(get_attribute_value(7).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(7)))->as<::Ifc2x3::IfcOrientationSelect>(true); }
void Ifc2x3::IfcRelAssociatesProfileProperties::setProfileOrientation(::Ifc2x3::IfcOrientationSelect* v) { set_attribute_value(7, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(7); }


const IfcParse::entity& Ifc2x3::IfcRelAssociatesProfileProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[685]); }
const IfcParse::entity& Ifc2x3::IfcRelAssociatesProfileProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[685]); }
Ifc2x3::IfcRelAssociatesProfileProperties::IfcRelAssociatesProfileProperties(IfcEntityInstanceData&& e) : IfcRelAssociates(std::move(e)) { }
Ifc2x3::IfcRelAssociatesProfileProperties::IfcRelAssociatesProfileProperties(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcRoot >::ptr v5_RelatedObjects, ::Ifc2x3::IfcProfileProperties* v6_RelatingProfileProperties, ::Ifc2x3::IfcShapeAspect* v7_ProfileSectionLocation, ::Ifc2x3::IfcOrientationSelect* v8_ProfileOrientation) : IfcRelAssociates(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize());set_attribute_value(5, v6_RelatingProfileProperties ? v6_RelatingProfileProperties->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_ProfileSectionLocation ? v7_ProfileSectionLocation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_ProfileOrientation ? v8_ProfileOrientation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelConnects


const IfcParse::entity& Ifc2x3::IfcRelConnects::declaration() const { return *((IfcParse::entity*)IFC2X3_types[688]); }
const IfcParse::entity& Ifc2x3::IfcRelConnects::Class() { return *((IfcParse::entity*)IFC2X3_types[688]); }
Ifc2x3::IfcRelConnects::IfcRelConnects(IfcEntityInstanceData&& e) : IfcRelationship(std::move(e)) { }
Ifc2x3::IfcRelConnects::IfcRelConnects(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcRelationship(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }; populate_derived(); }

// Function implementations for IfcRelConnectsElements
::Ifc2x3::IfcConnectionGeometry* Ifc2x3::IfcRelConnectsElements::ConnectionGeometry() const { if(get_attribute_value(4).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcConnectionGeometry>(true); }
void Ifc2x3::IfcRelConnectsElements::setConnectionGeometry(::Ifc2x3::IfcConnectionGeometry* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcElement* Ifc2x3::IfcRelConnectsElements::RelatingElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcElement>(true); }
void Ifc2x3::IfcRelConnectsElements::setRelatingElement(::Ifc2x3::IfcElement* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcElement* Ifc2x3::IfcRelConnectsElements::RelatedElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcElement>(true); }
void Ifc2x3::IfcRelConnectsElements::setRelatedElement(::Ifc2x3::IfcElement* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcRelConnectsElements::declaration() const { return *((IfcParse::entity*)IFC2X3_types[689]); }
const IfcParse::entity& Ifc2x3::IfcRelConnectsElements::Class() { return *((IfcParse::entity*)IFC2X3_types[689]); }
Ifc2x3::IfcRelConnectsElements::IfcRelConnectsElements(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelConnectsElements::IfcRelConnectsElements(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcConnectionGeometry* v5_ConnectionGeometry, ::Ifc2x3::IfcElement* v6_RelatingElement, ::Ifc2x3::IfcElement* v7_RelatedElement) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_ConnectionGeometry ? v5_ConnectionGeometry->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_RelatingElement ? v6_RelatingElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_RelatedElement ? v7_RelatedElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelConnectsPathElements
std::vector< int > /*[0:?]*/ Ifc2x3::IfcRelConnectsPathElements::RelatingPriorities() const {  std::vector< int > /*[0:?]*/ v = get_attribute_value(7); return v; }
void Ifc2x3::IfcRelConnectsPathElements::setRelatingPriorities(std::vector< int > /*[0:?]*/ v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
std::vector< int > /*[0:?]*/ Ifc2x3::IfcRelConnectsPathElements::RelatedPriorities() const {  std::vector< int > /*[0:?]*/ v = get_attribute_value(8); return v; }
void Ifc2x3::IfcRelConnectsPathElements::setRelatedPriorities(std::vector< int > /*[0:?]*/ v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
::Ifc2x3::IfcConnectionTypeEnum::Value Ifc2x3::IfcRelConnectsPathElements::RelatedConnectionType() const {  return ::Ifc2x3::IfcConnectionTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcRelConnectsPathElements::setRelatedConnectionType(::Ifc2x3::IfcConnectionTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcConnectionTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
::Ifc2x3::IfcConnectionTypeEnum::Value Ifc2x3::IfcRelConnectsPathElements::RelatingConnectionType() const {  return ::Ifc2x3::IfcConnectionTypeEnum::FromString(get_attribute_value(10)); }
void Ifc2x3::IfcRelConnectsPathElements::setRelatingConnectionType(::Ifc2x3::IfcConnectionTypeEnum::Value v) { set_attribute_value(10, EnumerationReference(&::Ifc2x3::IfcConnectionTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(10); }


const IfcParse::entity& Ifc2x3::IfcRelConnectsPathElements::declaration() const { return *((IfcParse::entity*)IFC2X3_types[690]); }
const IfcParse::entity& Ifc2x3::IfcRelConnectsPathElements::Class() { return *((IfcParse::entity*)IFC2X3_types[690]); }
Ifc2x3::IfcRelConnectsPathElements::IfcRelConnectsPathElements(IfcEntityInstanceData&& e) : IfcRelConnectsElements(std::move(e)) { }
Ifc2x3::IfcRelConnectsPathElements::IfcRelConnectsPathElements(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcConnectionGeometry* v5_ConnectionGeometry, ::Ifc2x3::IfcElement* v6_RelatingElement, ::Ifc2x3::IfcElement* v7_RelatedElement, std::vector< int > /*[0:?]*/ v8_RelatingPriorities, std::vector< int > /*[0:?]*/ v9_RelatedPriorities, ::Ifc2x3::IfcConnectionTypeEnum::Value v10_RelatedConnectionType, ::Ifc2x3::IfcConnectionTypeEnum::Value v11_RelatingConnectionType) : IfcRelConnectsElements(IfcEntityInstanceData(in_memory_attribute_storage(11))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_ConnectionGeometry ? v5_ConnectionGeometry->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_RelatingElement ? v6_RelatingElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_RelatedElement ? v7_RelatedElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, (v8_RelatingPriorities));set_attribute_value(8, (v9_RelatedPriorities));set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcConnectionTypeEnum::Class(),(size_t)v10_RelatedConnectionType)));set_attribute_value(10, (EnumerationReference(&::Ifc2x3::IfcConnectionTypeEnum::Class(),(size_t)v11_RelatingConnectionType)));; populate_derived(); }

// Function implementations for IfcRelConnectsPortToElement
::Ifc2x3::IfcPort* Ifc2x3::IfcRelConnectsPortToElement::RelatingPort() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcPort>(true); }
void Ifc2x3::IfcRelConnectsPortToElement::setRelatingPort(::Ifc2x3::IfcPort* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcElement* Ifc2x3::IfcRelConnectsPortToElement::RelatedElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcElement>(true); }
void Ifc2x3::IfcRelConnectsPortToElement::setRelatedElement(::Ifc2x3::IfcElement* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelConnectsPortToElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[692]); }
const IfcParse::entity& Ifc2x3::IfcRelConnectsPortToElement::Class() { return *((IfcParse::entity*)IFC2X3_types[692]); }
Ifc2x3::IfcRelConnectsPortToElement::IfcRelConnectsPortToElement(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelConnectsPortToElement::IfcRelConnectsPortToElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcPort* v5_RelatingPort, ::Ifc2x3::IfcElement* v6_RelatedElement) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_RelatingPort ? v5_RelatingPort->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_RelatedElement ? v6_RelatedElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelConnectsPorts
::Ifc2x3::IfcPort* Ifc2x3::IfcRelConnectsPorts::RelatingPort() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcPort>(true); }
void Ifc2x3::IfcRelConnectsPorts::setRelatingPort(::Ifc2x3::IfcPort* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcPort* Ifc2x3::IfcRelConnectsPorts::RelatedPort() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcPort>(true); }
void Ifc2x3::IfcRelConnectsPorts::setRelatedPort(::Ifc2x3::IfcPort* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcElement* Ifc2x3::IfcRelConnectsPorts::RealizingElement() const { if(get_attribute_value(6).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcElement>(true); }
void Ifc2x3::IfcRelConnectsPorts::setRealizingElement(::Ifc2x3::IfcElement* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcRelConnectsPorts::declaration() const { return *((IfcParse::entity*)IFC2X3_types[691]); }
const IfcParse::entity& Ifc2x3::IfcRelConnectsPorts::Class() { return *((IfcParse::entity*)IFC2X3_types[691]); }
Ifc2x3::IfcRelConnectsPorts::IfcRelConnectsPorts(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelConnectsPorts::IfcRelConnectsPorts(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcPort* v5_RelatingPort, ::Ifc2x3::IfcPort* v6_RelatedPort, ::Ifc2x3::IfcElement* v7_RealizingElement) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_RelatingPort ? v5_RelatingPort->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_RelatedPort ? v6_RelatedPort->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_RealizingElement ? v7_RealizingElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelConnectsStructuralActivity
::Ifc2x3::IfcStructuralActivityAssignmentSelect* Ifc2x3::IfcRelConnectsStructuralActivity::RelatingElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcStructuralActivityAssignmentSelect>(true); }
void Ifc2x3::IfcRelConnectsStructuralActivity::setRelatingElement(::Ifc2x3::IfcStructuralActivityAssignmentSelect* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcStructuralActivity* Ifc2x3::IfcRelConnectsStructuralActivity::RelatedStructuralActivity() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcStructuralActivity>(true); }
void Ifc2x3::IfcRelConnectsStructuralActivity::setRelatedStructuralActivity(::Ifc2x3::IfcStructuralActivity* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelConnectsStructuralActivity::declaration() const { return *((IfcParse::entity*)IFC2X3_types[693]); }
const IfcParse::entity& Ifc2x3::IfcRelConnectsStructuralActivity::Class() { return *((IfcParse::entity*)IFC2X3_types[693]); }
Ifc2x3::IfcRelConnectsStructuralActivity::IfcRelConnectsStructuralActivity(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelConnectsStructuralActivity::IfcRelConnectsStructuralActivity(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcStructuralActivityAssignmentSelect* v5_RelatingElement, ::Ifc2x3::IfcStructuralActivity* v6_RelatedStructuralActivity) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_RelatingElement ? v5_RelatingElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_RelatedStructuralActivity ? v6_RelatedStructuralActivity->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelConnectsStructuralElement
::Ifc2x3::IfcElement* Ifc2x3::IfcRelConnectsStructuralElement::RelatingElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcElement>(true); }
void Ifc2x3::IfcRelConnectsStructuralElement::setRelatingElement(::Ifc2x3::IfcElement* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcStructuralMember* Ifc2x3::IfcRelConnectsStructuralElement::RelatedStructuralMember() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcStructuralMember>(true); }
void Ifc2x3::IfcRelConnectsStructuralElement::setRelatedStructuralMember(::Ifc2x3::IfcStructuralMember* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelConnectsStructuralElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[694]); }
const IfcParse::entity& Ifc2x3::IfcRelConnectsStructuralElement::Class() { return *((IfcParse::entity*)IFC2X3_types[694]); }
Ifc2x3::IfcRelConnectsStructuralElement::IfcRelConnectsStructuralElement(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelConnectsStructuralElement::IfcRelConnectsStructuralElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcElement* v5_RelatingElement, ::Ifc2x3::IfcStructuralMember* v6_RelatedStructuralMember) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_RelatingElement ? v5_RelatingElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_RelatedStructuralMember ? v6_RelatedStructuralMember->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelConnectsStructuralMember
::Ifc2x3::IfcStructuralMember* Ifc2x3::IfcRelConnectsStructuralMember::RelatingStructuralMember() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcStructuralMember>(true); }
void Ifc2x3::IfcRelConnectsStructuralMember::setRelatingStructuralMember(::Ifc2x3::IfcStructuralMember* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcStructuralConnection* Ifc2x3::IfcRelConnectsStructuralMember::RelatedStructuralConnection() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcStructuralConnection>(true); }
void Ifc2x3::IfcRelConnectsStructuralMember::setRelatedStructuralConnection(::Ifc2x3::IfcStructuralConnection* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcBoundaryCondition* Ifc2x3::IfcRelConnectsStructuralMember::AppliedCondition() const { if(get_attribute_value(6).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcBoundaryCondition>(true); }
void Ifc2x3::IfcRelConnectsStructuralMember::setAppliedCondition(::Ifc2x3::IfcBoundaryCondition* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
::Ifc2x3::IfcStructuralConnectionCondition* Ifc2x3::IfcRelConnectsStructuralMember::AdditionalConditions() const { if(get_attribute_value(7).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(7)))->as<::Ifc2x3::IfcStructuralConnectionCondition>(true); }
void Ifc2x3::IfcRelConnectsStructuralMember::setAdditionalConditions(::Ifc2x3::IfcStructuralConnectionCondition* v) { set_attribute_value(7, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(7); }
boost::optional< double > Ifc2x3::IfcRelConnectsStructuralMember::SupportedLength() const { if(get_attribute_value(8).isNull()) { return boost::none; } double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcRelConnectsStructuralMember::setSupportedLength(boost::optional< double > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
::Ifc2x3::IfcAxis2Placement3D* Ifc2x3::IfcRelConnectsStructuralMember::ConditionCoordinateSystem() const { if(get_attribute_value(9).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(9)))->as<::Ifc2x3::IfcAxis2Placement3D>(true); }
void Ifc2x3::IfcRelConnectsStructuralMember::setConditionCoordinateSystem(::Ifc2x3::IfcAxis2Placement3D* v) { set_attribute_value(9, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcRelConnectsStructuralMember::declaration() const { return *((IfcParse::entity*)IFC2X3_types[695]); }
const IfcParse::entity& Ifc2x3::IfcRelConnectsStructuralMember::Class() { return *((IfcParse::entity*)IFC2X3_types[695]); }
Ifc2x3::IfcRelConnectsStructuralMember::IfcRelConnectsStructuralMember(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelConnectsStructuralMember::IfcRelConnectsStructuralMember(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcStructuralMember* v5_RelatingStructuralMember, ::Ifc2x3::IfcStructuralConnection* v6_RelatedStructuralConnection, ::Ifc2x3::IfcBoundaryCondition* v7_AppliedCondition, ::Ifc2x3::IfcStructuralConnectionCondition* v8_AdditionalConditions, boost::optional< double > v9_SupportedLength, ::Ifc2x3::IfcAxis2Placement3D* v10_ConditionCoordinateSystem) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_RelatingStructuralMember ? v5_RelatingStructuralMember->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_RelatedStructuralConnection ? v6_RelatedStructuralConnection->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_AppliedCondition ? v7_AppliedCondition->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_AdditionalConditions ? v8_AdditionalConditions->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v9_SupportedLength) {set_attribute_value(8, (*v9_SupportedLength)); }set_attribute_value(9, v10_ConditionCoordinateSystem ? v10_ConditionCoordinateSystem->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelConnectsWithEccentricity
::Ifc2x3::IfcConnectionGeometry* Ifc2x3::IfcRelConnectsWithEccentricity::ConnectionConstraint() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(10)))->as<::Ifc2x3::IfcConnectionGeometry>(true); }
void Ifc2x3::IfcRelConnectsWithEccentricity::setConnectionConstraint(::Ifc2x3::IfcConnectionGeometry* v) { set_attribute_value(10, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(10); }


const IfcParse::entity& Ifc2x3::IfcRelConnectsWithEccentricity::declaration() const { return *((IfcParse::entity*)IFC2X3_types[696]); }
const IfcParse::entity& Ifc2x3::IfcRelConnectsWithEccentricity::Class() { return *((IfcParse::entity*)IFC2X3_types[696]); }
Ifc2x3::IfcRelConnectsWithEccentricity::IfcRelConnectsWithEccentricity(IfcEntityInstanceData&& e) : IfcRelConnectsStructuralMember(std::move(e)) { }
Ifc2x3::IfcRelConnectsWithEccentricity::IfcRelConnectsWithEccentricity(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcStructuralMember* v5_RelatingStructuralMember, ::Ifc2x3::IfcStructuralConnection* v6_RelatedStructuralConnection, ::Ifc2x3::IfcBoundaryCondition* v7_AppliedCondition, ::Ifc2x3::IfcStructuralConnectionCondition* v8_AdditionalConditions, boost::optional< double > v9_SupportedLength, ::Ifc2x3::IfcAxis2Placement3D* v10_ConditionCoordinateSystem, ::Ifc2x3::IfcConnectionGeometry* v11_ConnectionConstraint) : IfcRelConnectsStructuralMember(IfcEntityInstanceData(in_memory_attribute_storage(11))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_RelatingStructuralMember ? v5_RelatingStructuralMember->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_RelatedStructuralConnection ? v6_RelatedStructuralConnection->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_AppliedCondition ? v7_AppliedCondition->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_AdditionalConditions ? v8_AdditionalConditions->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v9_SupportedLength) {set_attribute_value(8, (*v9_SupportedLength)); }set_attribute_value(9, v10_ConditionCoordinateSystem ? v10_ConditionCoordinateSystem->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(10, v11_ConnectionConstraint ? v11_ConnectionConstraint->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelConnectsWithRealizingElements
aggregate_of< ::Ifc2x3::IfcElement >::ptr Ifc2x3::IfcRelConnectsWithRealizingElements::RealizingElements() const {  aggregate_of_instance::ptr es = get_attribute_value(7); return es->as< ::Ifc2x3::IfcElement >(); }
void Ifc2x3::IfcRelConnectsWithRealizingElements::setRealizingElements(aggregate_of< ::Ifc2x3::IfcElement >::ptr v) { set_attribute_value(7, (v)->generalize());if constexpr (false)unset_attribute_value(7); }
boost::optional< std::string > Ifc2x3::IfcRelConnectsWithRealizingElements::ConnectionType() const { if(get_attribute_value(8).isNull()) { return boost::none; } std::string v = get_attribute_value(8); return v; }
void Ifc2x3::IfcRelConnectsWithRealizingElements::setConnectionType(boost::optional< std::string > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }


const IfcParse::entity& Ifc2x3::IfcRelConnectsWithRealizingElements::declaration() const { return *((IfcParse::entity*)IFC2X3_types[697]); }
const IfcParse::entity& Ifc2x3::IfcRelConnectsWithRealizingElements::Class() { return *((IfcParse::entity*)IFC2X3_types[697]); }
Ifc2x3::IfcRelConnectsWithRealizingElements::IfcRelConnectsWithRealizingElements(IfcEntityInstanceData&& e) : IfcRelConnectsElements(std::move(e)) { }
Ifc2x3::IfcRelConnectsWithRealizingElements::IfcRelConnectsWithRealizingElements(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcConnectionGeometry* v5_ConnectionGeometry, ::Ifc2x3::IfcElement* v6_RelatingElement, ::Ifc2x3::IfcElement* v7_RelatedElement, aggregate_of< ::Ifc2x3::IfcElement >::ptr v8_RealizingElements, boost::optional< std::string > v9_ConnectionType) : IfcRelConnectsElements(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_ConnectionGeometry ? v5_ConnectionGeometry->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_RelatingElement ? v6_RelatingElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_RelatedElement ? v7_RelatedElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, (v8_RealizingElements)->generalize()); if (v9_ConnectionType) {set_attribute_value(8, (*v9_ConnectionType)); }; populate_derived(); }

// Function implementations for IfcRelContainedInSpatialStructure
aggregate_of< ::Ifc2x3::IfcProduct >::ptr Ifc2x3::IfcRelContainedInSpatialStructure::RelatedElements() const {  aggregate_of_instance::ptr es = get_attribute_value(4); return es->as< ::Ifc2x3::IfcProduct >(); }
void Ifc2x3::IfcRelContainedInSpatialStructure::setRelatedElements(aggregate_of< ::Ifc2x3::IfcProduct >::ptr v) { set_attribute_value(4, (v)->generalize());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcSpatialStructureElement* Ifc2x3::IfcRelContainedInSpatialStructure::RelatingStructure() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcSpatialStructureElement>(true); }
void Ifc2x3::IfcRelContainedInSpatialStructure::setRelatingStructure(::Ifc2x3::IfcSpatialStructureElement* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelContainedInSpatialStructure::declaration() const { return *((IfcParse::entity*)IFC2X3_types[698]); }
const IfcParse::entity& Ifc2x3::IfcRelContainedInSpatialStructure::Class() { return *((IfcParse::entity*)IFC2X3_types[698]); }
Ifc2x3::IfcRelContainedInSpatialStructure::IfcRelContainedInSpatialStructure(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelContainedInSpatialStructure::IfcRelContainedInSpatialStructure(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcProduct >::ptr v5_RelatedElements, ::Ifc2x3::IfcSpatialStructureElement* v6_RelatingStructure) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedElements)->generalize());set_attribute_value(5, v6_RelatingStructure ? v6_RelatingStructure->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelCoversBldgElements
::Ifc2x3::IfcElement* Ifc2x3::IfcRelCoversBldgElements::RelatingBuildingElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcElement>(true); }
void Ifc2x3::IfcRelCoversBldgElements::setRelatingBuildingElement(::Ifc2x3::IfcElement* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
aggregate_of< ::Ifc2x3::IfcCovering >::ptr Ifc2x3::IfcRelCoversBldgElements::RelatedCoverings() const {  aggregate_of_instance::ptr es = get_attribute_value(5); return es->as< ::Ifc2x3::IfcCovering >(); }
void Ifc2x3::IfcRelCoversBldgElements::setRelatedCoverings(aggregate_of< ::Ifc2x3::IfcCovering >::ptr v) { set_attribute_value(5, (v)->generalize());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelCoversBldgElements::declaration() const { return *((IfcParse::entity*)IFC2X3_types[699]); }
const IfcParse::entity& Ifc2x3::IfcRelCoversBldgElements::Class() { return *((IfcParse::entity*)IFC2X3_types[699]); }
Ifc2x3::IfcRelCoversBldgElements::IfcRelCoversBldgElements(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelCoversBldgElements::IfcRelCoversBldgElements(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcElement* v5_RelatingBuildingElement, aggregate_of< ::Ifc2x3::IfcCovering >::ptr v6_RelatedCoverings) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_RelatingBuildingElement ? v5_RelatingBuildingElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, (v6_RelatedCoverings)->generalize());; populate_derived(); }

// Function implementations for IfcRelCoversSpaces
::Ifc2x3::IfcSpace* Ifc2x3::IfcRelCoversSpaces::RelatedSpace() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcSpace>(true); }
void Ifc2x3::IfcRelCoversSpaces::setRelatedSpace(::Ifc2x3::IfcSpace* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
aggregate_of< ::Ifc2x3::IfcCovering >::ptr Ifc2x3::IfcRelCoversSpaces::RelatedCoverings() const {  aggregate_of_instance::ptr es = get_attribute_value(5); return es->as< ::Ifc2x3::IfcCovering >(); }
void Ifc2x3::IfcRelCoversSpaces::setRelatedCoverings(aggregate_of< ::Ifc2x3::IfcCovering >::ptr v) { set_attribute_value(5, (v)->generalize());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelCoversSpaces::declaration() const { return *((IfcParse::entity*)IFC2X3_types[700]); }
const IfcParse::entity& Ifc2x3::IfcRelCoversSpaces::Class() { return *((IfcParse::entity*)IFC2X3_types[700]); }
Ifc2x3::IfcRelCoversSpaces::IfcRelCoversSpaces(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelCoversSpaces::IfcRelCoversSpaces(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcSpace* v5_RelatedSpace, aggregate_of< ::Ifc2x3::IfcCovering >::ptr v6_RelatedCoverings) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_RelatedSpace ? v5_RelatedSpace->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, (v6_RelatedCoverings)->generalize());; populate_derived(); }

// Function implementations for IfcRelDecomposes
::Ifc2x3::IfcObjectDefinition* Ifc2x3::IfcRelDecomposes::RelatingObject() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcObjectDefinition>(true); }
void Ifc2x3::IfcRelDecomposes::setRelatingObject(::Ifc2x3::IfcObjectDefinition* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr Ifc2x3::IfcRelDecomposes::RelatedObjects() const {  aggregate_of_instance::ptr es = get_attribute_value(5); return es->as< ::Ifc2x3::IfcObjectDefinition >(); }
void Ifc2x3::IfcRelDecomposes::setRelatedObjects(aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr v) { set_attribute_value(5, (v)->generalize());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelDecomposes::declaration() const { return *((IfcParse::entity*)IFC2X3_types[701]); }
const IfcParse::entity& Ifc2x3::IfcRelDecomposes::Class() { return *((IfcParse::entity*)IFC2X3_types[701]); }
Ifc2x3::IfcRelDecomposes::IfcRelDecomposes(IfcEntityInstanceData&& e) : IfcRelationship(std::move(e)) { }
Ifc2x3::IfcRelDecomposes::IfcRelDecomposes(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcObjectDefinition* v5_RelatingObject, aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr v6_RelatedObjects) : IfcRelationship(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_RelatingObject ? v5_RelatingObject->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, (v6_RelatedObjects)->generalize());; populate_derived(); }

// Function implementations for IfcRelDefines
aggregate_of< ::Ifc2x3::IfcObject >::ptr Ifc2x3::IfcRelDefines::RelatedObjects() const {  aggregate_of_instance::ptr es = get_attribute_value(4); return es->as< ::Ifc2x3::IfcObject >(); }
void Ifc2x3::IfcRelDefines::setRelatedObjects(aggregate_of< ::Ifc2x3::IfcObject >::ptr v) { set_attribute_value(4, (v)->generalize());if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcRelDefines::declaration() const { return *((IfcParse::entity*)IFC2X3_types[702]); }
const IfcParse::entity& Ifc2x3::IfcRelDefines::Class() { return *((IfcParse::entity*)IFC2X3_types[702]); }
Ifc2x3::IfcRelDefines::IfcRelDefines(IfcEntityInstanceData&& e) : IfcRelationship(std::move(e)) { }
Ifc2x3::IfcRelDefines::IfcRelDefines(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcObject >::ptr v5_RelatedObjects) : IfcRelationship(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize());; populate_derived(); }

// Function implementations for IfcRelDefinesByProperties
::Ifc2x3::IfcPropertySetDefinition* Ifc2x3::IfcRelDefinesByProperties::RelatingPropertyDefinition() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcPropertySetDefinition>(true); }
void Ifc2x3::IfcRelDefinesByProperties::setRelatingPropertyDefinition(::Ifc2x3::IfcPropertySetDefinition* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelDefinesByProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[703]); }
const IfcParse::entity& Ifc2x3::IfcRelDefinesByProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[703]); }
Ifc2x3::IfcRelDefinesByProperties::IfcRelDefinesByProperties(IfcEntityInstanceData&& e) : IfcRelDefines(std::move(e)) { }
Ifc2x3::IfcRelDefinesByProperties::IfcRelDefinesByProperties(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcObject >::ptr v5_RelatedObjects, ::Ifc2x3::IfcPropertySetDefinition* v6_RelatingPropertyDefinition) : IfcRelDefines(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize());set_attribute_value(5, v6_RelatingPropertyDefinition ? v6_RelatingPropertyDefinition->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelDefinesByType
::Ifc2x3::IfcTypeObject* Ifc2x3::IfcRelDefinesByType::RelatingType() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcTypeObject>(true); }
void Ifc2x3::IfcRelDefinesByType::setRelatingType(::Ifc2x3::IfcTypeObject* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelDefinesByType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[704]); }
const IfcParse::entity& Ifc2x3::IfcRelDefinesByType::Class() { return *((IfcParse::entity*)IFC2X3_types[704]); }
Ifc2x3::IfcRelDefinesByType::IfcRelDefinesByType(IfcEntityInstanceData&& e) : IfcRelDefines(std::move(e)) { }
Ifc2x3::IfcRelDefinesByType::IfcRelDefinesByType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcObject >::ptr v5_RelatedObjects, ::Ifc2x3::IfcTypeObject* v6_RelatingType) : IfcRelDefines(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize());set_attribute_value(5, v6_RelatingType ? v6_RelatingType->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelFillsElement
::Ifc2x3::IfcOpeningElement* Ifc2x3::IfcRelFillsElement::RelatingOpeningElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcOpeningElement>(true); }
void Ifc2x3::IfcRelFillsElement::setRelatingOpeningElement(::Ifc2x3::IfcOpeningElement* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcElement* Ifc2x3::IfcRelFillsElement::RelatedBuildingElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcElement>(true); }
void Ifc2x3::IfcRelFillsElement::setRelatedBuildingElement(::Ifc2x3::IfcElement* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelFillsElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[705]); }
const IfcParse::entity& Ifc2x3::IfcRelFillsElement::Class() { return *((IfcParse::entity*)IFC2X3_types[705]); }
Ifc2x3::IfcRelFillsElement::IfcRelFillsElement(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelFillsElement::IfcRelFillsElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcOpeningElement* v5_RelatingOpeningElement, ::Ifc2x3::IfcElement* v6_RelatedBuildingElement) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_RelatingOpeningElement ? v5_RelatingOpeningElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_RelatedBuildingElement ? v6_RelatedBuildingElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelFlowControlElements
aggregate_of< ::Ifc2x3::IfcDistributionControlElement >::ptr Ifc2x3::IfcRelFlowControlElements::RelatedControlElements() const {  aggregate_of_instance::ptr es = get_attribute_value(4); return es->as< ::Ifc2x3::IfcDistributionControlElement >(); }
void Ifc2x3::IfcRelFlowControlElements::setRelatedControlElements(aggregate_of< ::Ifc2x3::IfcDistributionControlElement >::ptr v) { set_attribute_value(4, (v)->generalize());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcDistributionFlowElement* Ifc2x3::IfcRelFlowControlElements::RelatingFlowElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcDistributionFlowElement>(true); }
void Ifc2x3::IfcRelFlowControlElements::setRelatingFlowElement(::Ifc2x3::IfcDistributionFlowElement* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelFlowControlElements::declaration() const { return *((IfcParse::entity*)IFC2X3_types[706]); }
const IfcParse::entity& Ifc2x3::IfcRelFlowControlElements::Class() { return *((IfcParse::entity*)IFC2X3_types[706]); }
Ifc2x3::IfcRelFlowControlElements::IfcRelFlowControlElements(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelFlowControlElements::IfcRelFlowControlElements(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcDistributionControlElement >::ptr v5_RelatedControlElements, ::Ifc2x3::IfcDistributionFlowElement* v6_RelatingFlowElement) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedControlElements)->generalize());set_attribute_value(5, v6_RelatingFlowElement ? v6_RelatingFlowElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelInteractionRequirements
boost::optional< double > Ifc2x3::IfcRelInteractionRequirements::DailyInteraction() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcRelInteractionRequirements::setDailyInteraction(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< double > Ifc2x3::IfcRelInteractionRequirements::ImportanceRating() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcRelInteractionRequirements::setImportanceRating(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
::Ifc2x3::IfcSpatialStructureElement* Ifc2x3::IfcRelInteractionRequirements::LocationOfInteraction() const { if(get_attribute_value(6).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcSpatialStructureElement>(true); }
void Ifc2x3::IfcRelInteractionRequirements::setLocationOfInteraction(::Ifc2x3::IfcSpatialStructureElement* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
::Ifc2x3::IfcSpaceProgram* Ifc2x3::IfcRelInteractionRequirements::RelatedSpaceProgram() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(7)))->as<::Ifc2x3::IfcSpaceProgram>(true); }
void Ifc2x3::IfcRelInteractionRequirements::setRelatedSpaceProgram(::Ifc2x3::IfcSpaceProgram* v) { set_attribute_value(7, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(7); }
::Ifc2x3::IfcSpaceProgram* Ifc2x3::IfcRelInteractionRequirements::RelatingSpaceProgram() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(8)))->as<::Ifc2x3::IfcSpaceProgram>(true); }
void Ifc2x3::IfcRelInteractionRequirements::setRelatingSpaceProgram(::Ifc2x3::IfcSpaceProgram* v) { set_attribute_value(8, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(8); }


const IfcParse::entity& Ifc2x3::IfcRelInteractionRequirements::declaration() const { return *((IfcParse::entity*)IFC2X3_types[707]); }
const IfcParse::entity& Ifc2x3::IfcRelInteractionRequirements::Class() { return *((IfcParse::entity*)IFC2X3_types[707]); }
Ifc2x3::IfcRelInteractionRequirements::IfcRelInteractionRequirements(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelInteractionRequirements::IfcRelInteractionRequirements(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_DailyInteraction, boost::optional< double > v6_ImportanceRating, ::Ifc2x3::IfcSpatialStructureElement* v7_LocationOfInteraction, ::Ifc2x3::IfcSpaceProgram* v8_RelatedSpaceProgram, ::Ifc2x3::IfcSpaceProgram* v9_RelatingSpaceProgram) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_DailyInteraction) {set_attribute_value(4, (*v5_DailyInteraction)); } if (v6_ImportanceRating) {set_attribute_value(5, (*v6_ImportanceRating)); }set_attribute_value(6, v7_LocationOfInteraction ? v7_LocationOfInteraction->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_RelatedSpaceProgram ? v8_RelatedSpaceProgram->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(8, v9_RelatingSpaceProgram ? v9_RelatingSpaceProgram->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelNests


const IfcParse::entity& Ifc2x3::IfcRelNests::declaration() const { return *((IfcParse::entity*)IFC2X3_types[708]); }
const IfcParse::entity& Ifc2x3::IfcRelNests::Class() { return *((IfcParse::entity*)IFC2X3_types[708]); }
Ifc2x3::IfcRelNests::IfcRelNests(IfcEntityInstanceData&& e) : IfcRelDecomposes(std::move(e)) { }
Ifc2x3::IfcRelNests::IfcRelNests(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcObjectDefinition* v5_RelatingObject, aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr v6_RelatedObjects) : IfcRelDecomposes(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_RelatingObject ? v5_RelatingObject->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, (v6_RelatedObjects)->generalize());; populate_derived(); }

// Function implementations for IfcRelOccupiesSpaces


const IfcParse::entity& Ifc2x3::IfcRelOccupiesSpaces::declaration() const { return *((IfcParse::entity*)IFC2X3_types[709]); }
const IfcParse::entity& Ifc2x3::IfcRelOccupiesSpaces::Class() { return *((IfcParse::entity*)IFC2X3_types[709]); }
Ifc2x3::IfcRelOccupiesSpaces::IfcRelOccupiesSpaces(IfcEntityInstanceData&& e) : IfcRelAssignsToActor(std::move(e)) { }
Ifc2x3::IfcRelOccupiesSpaces::IfcRelOccupiesSpaces(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< ::Ifc2x3::IfcObjectTypeEnum::Value > v6_RelatedObjectsType, ::Ifc2x3::IfcActor* v7_RelatingActor, ::Ifc2x3::IfcActorRole* v8_ActingRole) : IfcRelAssignsToActor(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }set_attribute_value(6, v7_RelatingActor ? v7_RelatingActor->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_ActingRole ? v8_ActingRole->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelOverridesProperties
aggregate_of< ::Ifc2x3::IfcProperty >::ptr Ifc2x3::IfcRelOverridesProperties::OverridingProperties() const {  aggregate_of_instance::ptr es = get_attribute_value(6); return es->as< ::Ifc2x3::IfcProperty >(); }
void Ifc2x3::IfcRelOverridesProperties::setOverridingProperties(aggregate_of< ::Ifc2x3::IfcProperty >::ptr v) { set_attribute_value(6, (v)->generalize());if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcRelOverridesProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[710]); }
const IfcParse::entity& Ifc2x3::IfcRelOverridesProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[710]); }
Ifc2x3::IfcRelOverridesProperties::IfcRelOverridesProperties(IfcEntityInstanceData&& e) : IfcRelDefinesByProperties(std::move(e)) { }
Ifc2x3::IfcRelOverridesProperties::IfcRelOverridesProperties(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcObject >::ptr v5_RelatedObjects, ::Ifc2x3::IfcPropertySetDefinition* v6_RelatingPropertyDefinition, aggregate_of< ::Ifc2x3::IfcProperty >::ptr v7_OverridingProperties) : IfcRelDefinesByProperties(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize());set_attribute_value(5, v6_RelatingPropertyDefinition ? v6_RelatingPropertyDefinition->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, (v7_OverridingProperties)->generalize());; populate_derived(); }

// Function implementations for IfcRelProjectsElement
::Ifc2x3::IfcElement* Ifc2x3::IfcRelProjectsElement::RelatingElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcElement>(true); }
void Ifc2x3::IfcRelProjectsElement::setRelatingElement(::Ifc2x3::IfcElement* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcFeatureElementAddition* Ifc2x3::IfcRelProjectsElement::RelatedFeatureElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcFeatureElementAddition>(true); }
void Ifc2x3::IfcRelProjectsElement::setRelatedFeatureElement(::Ifc2x3::IfcFeatureElementAddition* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelProjectsElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[711]); }
const IfcParse::entity& Ifc2x3::IfcRelProjectsElement::Class() { return *((IfcParse::entity*)IFC2X3_types[711]); }
Ifc2x3::IfcRelProjectsElement::IfcRelProjectsElement(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelProjectsElement::IfcRelProjectsElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcElement* v5_RelatingElement, ::Ifc2x3::IfcFeatureElementAddition* v6_RelatedFeatureElement) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_RelatingElement ? v5_RelatingElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_RelatedFeatureElement ? v6_RelatedFeatureElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelReferencedInSpatialStructure
aggregate_of< ::Ifc2x3::IfcProduct >::ptr Ifc2x3::IfcRelReferencedInSpatialStructure::RelatedElements() const {  aggregate_of_instance::ptr es = get_attribute_value(4); return es->as< ::Ifc2x3::IfcProduct >(); }
void Ifc2x3::IfcRelReferencedInSpatialStructure::setRelatedElements(aggregate_of< ::Ifc2x3::IfcProduct >::ptr v) { set_attribute_value(4, (v)->generalize());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcSpatialStructureElement* Ifc2x3::IfcRelReferencedInSpatialStructure::RelatingStructure() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcSpatialStructureElement>(true); }
void Ifc2x3::IfcRelReferencedInSpatialStructure::setRelatingStructure(::Ifc2x3::IfcSpatialStructureElement* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelReferencedInSpatialStructure::declaration() const { return *((IfcParse::entity*)IFC2X3_types[712]); }
const IfcParse::entity& Ifc2x3::IfcRelReferencedInSpatialStructure::Class() { return *((IfcParse::entity*)IFC2X3_types[712]); }
Ifc2x3::IfcRelReferencedInSpatialStructure::IfcRelReferencedInSpatialStructure(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelReferencedInSpatialStructure::IfcRelReferencedInSpatialStructure(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcProduct >::ptr v5_RelatedElements, ::Ifc2x3::IfcSpatialStructureElement* v6_RelatingStructure) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedElements)->generalize());set_attribute_value(5, v6_RelatingStructure ? v6_RelatingStructure->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelSchedulesCostItems


const IfcParse::entity& Ifc2x3::IfcRelSchedulesCostItems::declaration() const { return *((IfcParse::entity*)IFC2X3_types[713]); }
const IfcParse::entity& Ifc2x3::IfcRelSchedulesCostItems::Class() { return *((IfcParse::entity*)IFC2X3_types[713]); }
Ifc2x3::IfcRelSchedulesCostItems::IfcRelSchedulesCostItems(IfcEntityInstanceData&& e) : IfcRelAssignsToControl(std::move(e)) { }
Ifc2x3::IfcRelSchedulesCostItems::IfcRelSchedulesCostItems(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, aggregate_of< ::Ifc2x3::IfcObjectDefinition >::ptr v5_RelatedObjects, boost::optional< ::Ifc2x3::IfcObjectTypeEnum::Value > v6_RelatedObjectsType, ::Ifc2x3::IfcControl* v7_RelatingControl) : IfcRelAssignsToControl(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatedObjects)->generalize()); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }set_attribute_value(6, v7_RelatingControl ? v7_RelatingControl->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelSequence
::Ifc2x3::IfcProcess* Ifc2x3::IfcRelSequence::RelatingProcess() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcProcess>(true); }
void Ifc2x3::IfcRelSequence::setRelatingProcess(::Ifc2x3::IfcProcess* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcProcess* Ifc2x3::IfcRelSequence::RelatedProcess() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcProcess>(true); }
void Ifc2x3::IfcRelSequence::setRelatedProcess(::Ifc2x3::IfcProcess* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }
double Ifc2x3::IfcRelSequence::TimeLag() const {  double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcRelSequence::setTimeLag(double v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
::Ifc2x3::IfcSequenceEnum::Value Ifc2x3::IfcRelSequence::SequenceType() const {  return ::Ifc2x3::IfcSequenceEnum::FromString(get_attribute_value(7)); }
void Ifc2x3::IfcRelSequence::setSequenceType(::Ifc2x3::IfcSequenceEnum::Value v) { set_attribute_value(7, EnumerationReference(&::Ifc2x3::IfcSequenceEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }


const IfcParse::entity& Ifc2x3::IfcRelSequence::declaration() const { return *((IfcParse::entity*)IFC2X3_types[714]); }
const IfcParse::entity& Ifc2x3::IfcRelSequence::Class() { return *((IfcParse::entity*)IFC2X3_types[714]); }
Ifc2x3::IfcRelSequence::IfcRelSequence(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelSequence::IfcRelSequence(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcProcess* v5_RelatingProcess, ::Ifc2x3::IfcProcess* v6_RelatedProcess, double v7_TimeLag, ::Ifc2x3::IfcSequenceEnum::Value v8_SequenceType) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_RelatingProcess ? v5_RelatingProcess->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_RelatedProcess ? v6_RelatedProcess->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, (v7_TimeLag));set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcSequenceEnum::Class(),(size_t)v8_SequenceType)));; populate_derived(); }

// Function implementations for IfcRelServicesBuildings
::Ifc2x3::IfcSystem* Ifc2x3::IfcRelServicesBuildings::RelatingSystem() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcSystem>(true); }
void Ifc2x3::IfcRelServicesBuildings::setRelatingSystem(::Ifc2x3::IfcSystem* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
aggregate_of< ::Ifc2x3::IfcSpatialStructureElement >::ptr Ifc2x3::IfcRelServicesBuildings::RelatedBuildings() const {  aggregate_of_instance::ptr es = get_attribute_value(5); return es->as< ::Ifc2x3::IfcSpatialStructureElement >(); }
void Ifc2x3::IfcRelServicesBuildings::setRelatedBuildings(aggregate_of< ::Ifc2x3::IfcSpatialStructureElement >::ptr v) { set_attribute_value(5, (v)->generalize());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelServicesBuildings::declaration() const { return *((IfcParse::entity*)IFC2X3_types[715]); }
const IfcParse::entity& Ifc2x3::IfcRelServicesBuildings::Class() { return *((IfcParse::entity*)IFC2X3_types[715]); }
Ifc2x3::IfcRelServicesBuildings::IfcRelServicesBuildings(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelServicesBuildings::IfcRelServicesBuildings(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcSystem* v5_RelatingSystem, aggregate_of< ::Ifc2x3::IfcSpatialStructureElement >::ptr v6_RelatedBuildings) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_RelatingSystem ? v5_RelatingSystem->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, (v6_RelatedBuildings)->generalize());; populate_derived(); }

// Function implementations for IfcRelSpaceBoundary
::Ifc2x3::IfcSpace* Ifc2x3::IfcRelSpaceBoundary::RelatingSpace() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcSpace>(true); }
void Ifc2x3::IfcRelSpaceBoundary::setRelatingSpace(::Ifc2x3::IfcSpace* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcElement* Ifc2x3::IfcRelSpaceBoundary::RelatedBuildingElement() const { if(get_attribute_value(5).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcElement>(true); }
void Ifc2x3::IfcRelSpaceBoundary::setRelatedBuildingElement(::Ifc2x3::IfcElement* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcConnectionGeometry* Ifc2x3::IfcRelSpaceBoundary::ConnectionGeometry() const { if(get_attribute_value(6).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcConnectionGeometry>(true); }
void Ifc2x3::IfcRelSpaceBoundary::setConnectionGeometry(::Ifc2x3::IfcConnectionGeometry* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
::Ifc2x3::IfcPhysicalOrVirtualEnum::Value Ifc2x3::IfcRelSpaceBoundary::PhysicalOrVirtualBoundary() const {  return ::Ifc2x3::IfcPhysicalOrVirtualEnum::FromString(get_attribute_value(7)); }
void Ifc2x3::IfcRelSpaceBoundary::setPhysicalOrVirtualBoundary(::Ifc2x3::IfcPhysicalOrVirtualEnum::Value v) { set_attribute_value(7, EnumerationReference(&::Ifc2x3::IfcPhysicalOrVirtualEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }
::Ifc2x3::IfcInternalOrExternalEnum::Value Ifc2x3::IfcRelSpaceBoundary::InternalOrExternalBoundary() const {  return ::Ifc2x3::IfcInternalOrExternalEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcRelSpaceBoundary::setInternalOrExternalBoundary(::Ifc2x3::IfcInternalOrExternalEnum::Value v) { set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcInternalOrExternalEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }


const IfcParse::entity& Ifc2x3::IfcRelSpaceBoundary::declaration() const { return *((IfcParse::entity*)IFC2X3_types[716]); }
const IfcParse::entity& Ifc2x3::IfcRelSpaceBoundary::Class() { return *((IfcParse::entity*)IFC2X3_types[716]); }
Ifc2x3::IfcRelSpaceBoundary::IfcRelSpaceBoundary(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelSpaceBoundary::IfcRelSpaceBoundary(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcSpace* v5_RelatingSpace, ::Ifc2x3::IfcElement* v6_RelatedBuildingElement, ::Ifc2x3::IfcConnectionGeometry* v7_ConnectionGeometry, ::Ifc2x3::IfcPhysicalOrVirtualEnum::Value v8_PhysicalOrVirtualBoundary, ::Ifc2x3::IfcInternalOrExternalEnum::Value v9_InternalOrExternalBoundary) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_RelatingSpace ? v5_RelatingSpace->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_RelatedBuildingElement ? v6_RelatedBuildingElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_ConnectionGeometry ? v7_ConnectionGeometry->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcPhysicalOrVirtualEnum::Class(),(size_t)v8_PhysicalOrVirtualBoundary)));set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcInternalOrExternalEnum::Class(),(size_t)v9_InternalOrExternalBoundary)));; populate_derived(); }

// Function implementations for IfcRelVoidsElement
::Ifc2x3::IfcElement* Ifc2x3::IfcRelVoidsElement::RelatingBuildingElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcElement>(true); }
void Ifc2x3::IfcRelVoidsElement::setRelatingBuildingElement(::Ifc2x3::IfcElement* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcFeatureElementSubtraction* Ifc2x3::IfcRelVoidsElement::RelatedOpeningElement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcFeatureElementSubtraction>(true); }
void Ifc2x3::IfcRelVoidsElement::setRelatedOpeningElement(::Ifc2x3::IfcFeatureElementSubtraction* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRelVoidsElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[717]); }
const IfcParse::entity& Ifc2x3::IfcRelVoidsElement::Class() { return *((IfcParse::entity*)IFC2X3_types[717]); }
Ifc2x3::IfcRelVoidsElement::IfcRelVoidsElement(IfcEntityInstanceData&& e) : IfcRelConnects(std::move(e)) { }
Ifc2x3::IfcRelVoidsElement::IfcRelVoidsElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcElement* v5_RelatingBuildingElement, ::Ifc2x3::IfcFeatureElementSubtraction* v6_RelatedOpeningElement) : IfcRelConnects(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_RelatingBuildingElement ? v5_RelatingBuildingElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_RelatedOpeningElement ? v6_RelatedOpeningElement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcRelationship


const IfcParse::entity& Ifc2x3::IfcRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[686]); }
const IfcParse::entity& Ifc2x3::IfcRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[686]); }
Ifc2x3::IfcRelationship::IfcRelationship(IfcEntityInstanceData&& e) : IfcRoot(std::move(e)) { }
Ifc2x3::IfcRelationship::IfcRelationship(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcRoot(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }; populate_derived(); }

// Function implementations for IfcRelaxation
double Ifc2x3::IfcRelaxation::RelaxationValue() const {  double v = get_attribute_value(0); return v; }
void Ifc2x3::IfcRelaxation::setRelaxationValue(double v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
double Ifc2x3::IfcRelaxation::InitialStress() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcRelaxation::setInitialStress(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcRelaxation::declaration() const { return *((IfcParse::entity*)IFC2X3_types[687]); }
const IfcParse::entity& Ifc2x3::IfcRelaxation::Class() { return *((IfcParse::entity*)IFC2X3_types[687]); }
Ifc2x3::IfcRelaxation::IfcRelaxation(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcRelaxation::IfcRelaxation(double v1_RelaxationValue, double v2_InitialStress) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (v1_RelaxationValue));set_attribute_value(1, (v2_InitialStress));; populate_derived(); }

// Function implementations for IfcRepresentation
::Ifc2x3::IfcRepresentationContext* Ifc2x3::IfcRepresentation::ContextOfItems() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcRepresentationContext>(true); }
void Ifc2x3::IfcRepresentation::setContextOfItems(::Ifc2x3::IfcRepresentationContext* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
boost::optional< std::string > Ifc2x3::IfcRepresentation::RepresentationIdentifier() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcRepresentation::setRepresentationIdentifier(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< std::string > Ifc2x3::IfcRepresentation::RepresentationType() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcRepresentation::setRepresentationType(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
aggregate_of< ::Ifc2x3::IfcRepresentationItem >::ptr Ifc2x3::IfcRepresentation::Items() const {  aggregate_of_instance::ptr es = get_attribute_value(3); return es->as< ::Ifc2x3::IfcRepresentationItem >(); }
void Ifc2x3::IfcRepresentation::setItems(aggregate_of< ::Ifc2x3::IfcRepresentationItem >::ptr v) { set_attribute_value(3, (v)->generalize());if constexpr (false)unset_attribute_value(3); }

::Ifc2x3::IfcRepresentationMap::list::ptr Ifc2x3::IfcRepresentation::RepresentationMap() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[721], 1)->as<IfcRepresentationMap>(); }
::Ifc2x3::IfcPresentationLayerAssignment::list::ptr Ifc2x3::IfcRepresentation::LayerAssignments() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[591], 2)->as<IfcPresentationLayerAssignment>(); }
::Ifc2x3::IfcProductRepresentation::list::ptr Ifc2x3::IfcRepresentation::OfProductRepresentation() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[602], 2)->as<IfcProductRepresentation>(); }

const IfcParse::entity& Ifc2x3::IfcRepresentation::declaration() const { return *((IfcParse::entity*)IFC2X3_types[718]); }
const IfcParse::entity& Ifc2x3::IfcRepresentation::Class() { return *((IfcParse::entity*)IFC2X3_types[718]); }
Ifc2x3::IfcRepresentation::IfcRepresentation(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcRepresentation::IfcRepresentation(::Ifc2x3::IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, aggregate_of< ::Ifc2x3::IfcRepresentationItem >::ptr v4_Items) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_ContextOfItems ? v1_ContextOfItems->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_RepresentationIdentifier) {set_attribute_value(1, (*v2_RepresentationIdentifier)); } if (v3_RepresentationType) {set_attribute_value(2, (*v3_RepresentationType)); }set_attribute_value(3, (v4_Items)->generalize());; populate_derived(); }

// Function implementations for IfcRepresentationContext
boost::optional< std::string > Ifc2x3::IfcRepresentationContext::ContextIdentifier() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcRepresentationContext::setContextIdentifier(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
boost::optional< std::string > Ifc2x3::IfcRepresentationContext::ContextType() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcRepresentationContext::setContextType(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }

::Ifc2x3::IfcRepresentation::list::ptr Ifc2x3::IfcRepresentationContext::RepresentationsInContext() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[718], 0)->as<IfcRepresentation>(); }

const IfcParse::entity& Ifc2x3::IfcRepresentationContext::declaration() const { return *((IfcParse::entity*)IFC2X3_types[719]); }
const IfcParse::entity& Ifc2x3::IfcRepresentationContext::Class() { return *((IfcParse::entity*)IFC2X3_types[719]); }
Ifc2x3::IfcRepresentationContext::IfcRepresentationContext(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcRepresentationContext::IfcRepresentationContext(boost::optional< std::string > v1_ContextIdentifier, boost::optional< std::string > v2_ContextType) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) {  if (v1_ContextIdentifier) {set_attribute_value(0, (*v1_ContextIdentifier)); } if (v2_ContextType) {set_attribute_value(1, (*v2_ContextType)); }; populate_derived(); }

// Function implementations for IfcRepresentationItem

::Ifc2x3::IfcPresentationLayerAssignment::list::ptr Ifc2x3::IfcRepresentationItem::LayerAssignments() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[591], 2)->as<IfcPresentationLayerAssignment>(); }
::Ifc2x3::IfcStyledItem::list::ptr Ifc2x3::IfcRepresentationItem::StyledByItem() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[839], 0)->as<IfcStyledItem>(); }

const IfcParse::entity& Ifc2x3::IfcRepresentationItem::declaration() const { return *((IfcParse::entity*)IFC2X3_types[720]); }
const IfcParse::entity& Ifc2x3::IfcRepresentationItem::Class() { return *((IfcParse::entity*)IFC2X3_types[720]); }
Ifc2x3::IfcRepresentationItem::IfcRepresentationItem(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcRepresentationItem::IfcRepresentationItem() : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(0))) { ; populate_derived(); }

// Function implementations for IfcRepresentationMap
::Ifc2x3::IfcAxis2Placement* Ifc2x3::IfcRepresentationMap::MappingOrigin() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcAxis2Placement>(true); }
void Ifc2x3::IfcRepresentationMap::setMappingOrigin(::Ifc2x3::IfcAxis2Placement* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcRepresentation* Ifc2x3::IfcRepresentationMap::MappedRepresentation() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcRepresentation>(true); }
void Ifc2x3::IfcRepresentationMap::setMappedRepresentation(::Ifc2x3::IfcRepresentation* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }

::Ifc2x3::IfcMappedItem::list::ptr Ifc2x3::IfcRepresentationMap::MapUsage() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[471], 0)->as<IfcMappedItem>(); }

const IfcParse::entity& Ifc2x3::IfcRepresentationMap::declaration() const { return *((IfcParse::entity*)IFC2X3_types[721]); }
const IfcParse::entity& Ifc2x3::IfcRepresentationMap::Class() { return *((IfcParse::entity*)IFC2X3_types[721]); }
Ifc2x3::IfcRepresentationMap::IfcRepresentationMap(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcRepresentationMap::IfcRepresentationMap(::Ifc2x3::IfcAxis2Placement* v1_MappingOrigin, ::Ifc2x3::IfcRepresentation* v2_MappedRepresentation) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_MappingOrigin ? v1_MappingOrigin->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_MappedRepresentation ? v2_MappedRepresentation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcResource

::Ifc2x3::IfcRelAssignsToResource::list::ptr Ifc2x3::IfcResource::ResourceOf() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[676], 6)->as<IfcRelAssignsToResource>(); }

const IfcParse::entity& Ifc2x3::IfcResource::declaration() const { return *((IfcParse::entity*)IFC2X3_types[722]); }
const IfcParse::entity& Ifc2x3::IfcResource::Class() { return *((IfcParse::entity*)IFC2X3_types[722]); }
Ifc2x3::IfcResource::IfcResource(IfcEntityInstanceData&& e) : IfcObject(std::move(e)) { }
Ifc2x3::IfcResource::IfcResource(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcObject(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }; populate_derived(); }

// Function implementations for IfcRevolvedAreaSolid
::Ifc2x3::IfcAxis1Placement* Ifc2x3::IfcRevolvedAreaSolid::Axis() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcAxis1Placement>(true); }
void Ifc2x3::IfcRevolvedAreaSolid::setAxis(::Ifc2x3::IfcAxis1Placement* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
double Ifc2x3::IfcRevolvedAreaSolid::Angle() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcRevolvedAreaSolid::setAngle(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcRevolvedAreaSolid::declaration() const { return *((IfcParse::entity*)IFC2X3_types[724]); }
const IfcParse::entity& Ifc2x3::IfcRevolvedAreaSolid::Class() { return *((IfcParse::entity*)IFC2X3_types[724]); }
Ifc2x3::IfcRevolvedAreaSolid::IfcRevolvedAreaSolid(IfcEntityInstanceData&& e) : IfcSweptAreaSolid(std::move(e)) { }
Ifc2x3::IfcRevolvedAreaSolid::IfcRevolvedAreaSolid(::Ifc2x3::IfcProfileDef* v1_SweptArea, ::Ifc2x3::IfcAxis2Placement3D* v2_Position, ::Ifc2x3::IfcAxis1Placement* v3_Axis, double v4_Angle) : IfcSweptAreaSolid(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_SweptArea ? v1_SweptArea->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_Position ? v2_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_Axis ? v3_Axis->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_Angle));; populate_derived(); }

// Function implementations for IfcRibPlateProfileProperties
boost::optional< double > Ifc2x3::IfcRibPlateProfileProperties::Thickness() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcRibPlateProfileProperties::setThickness(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcRibPlateProfileProperties::RibHeight() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcRibPlateProfileProperties::setRibHeight(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< double > Ifc2x3::IfcRibPlateProfileProperties::RibWidth() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcRibPlateProfileProperties::setRibWidth(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< double > Ifc2x3::IfcRibPlateProfileProperties::RibSpacing() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcRibPlateProfileProperties::setRibSpacing(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
::Ifc2x3::IfcRibPlateDirectionEnum::Value Ifc2x3::IfcRibPlateProfileProperties::Direction() const {  return ::Ifc2x3::IfcRibPlateDirectionEnum::FromString(get_attribute_value(6)); }
void Ifc2x3::IfcRibPlateProfileProperties::setDirection(::Ifc2x3::IfcRibPlateDirectionEnum::Value v) { set_attribute_value(6, EnumerationReference(&::Ifc2x3::IfcRibPlateDirectionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcRibPlateProfileProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[726]); }
const IfcParse::entity& Ifc2x3::IfcRibPlateProfileProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[726]); }
Ifc2x3::IfcRibPlateProfileProperties::IfcRibPlateProfileProperties(IfcEntityInstanceData&& e) : IfcProfileProperties(std::move(e)) { }
Ifc2x3::IfcRibPlateProfileProperties::IfcRibPlateProfileProperties(boost::optional< std::string > v1_ProfileName, ::Ifc2x3::IfcProfileDef* v2_ProfileDefinition, boost::optional< double > v3_Thickness, boost::optional< double > v4_RibHeight, boost::optional< double > v5_RibWidth, boost::optional< double > v6_RibSpacing, ::Ifc2x3::IfcRibPlateDirectionEnum::Value v7_Direction) : IfcProfileProperties(IfcEntityInstanceData(in_memory_attribute_storage(7))) {  if (v1_ProfileName) {set_attribute_value(0, (*v1_ProfileName)); }set_attribute_value(1, v2_ProfileDefinition ? v2_ProfileDefinition->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Thickness) {set_attribute_value(2, (*v3_Thickness)); } if (v4_RibHeight) {set_attribute_value(3, (*v4_RibHeight)); } if (v5_RibWidth) {set_attribute_value(4, (*v5_RibWidth)); } if (v6_RibSpacing) {set_attribute_value(5, (*v6_RibSpacing)); }set_attribute_value(6, (EnumerationReference(&::Ifc2x3::IfcRibPlateDirectionEnum::Class(),(size_t)v7_Direction)));; populate_derived(); }

// Function implementations for IfcRightCircularCone
double Ifc2x3::IfcRightCircularCone::Height() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcRightCircularCone::setHeight(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
double Ifc2x3::IfcRightCircularCone::BottomRadius() const {  double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcRightCircularCone::setBottomRadius(double v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcRightCircularCone::declaration() const { return *((IfcParse::entity*)IFC2X3_types[727]); }
const IfcParse::entity& Ifc2x3::IfcRightCircularCone::Class() { return *((IfcParse::entity*)IFC2X3_types[727]); }
Ifc2x3::IfcRightCircularCone::IfcRightCircularCone(IfcEntityInstanceData&& e) : IfcCsgPrimitive3D(std::move(e)) { }
Ifc2x3::IfcRightCircularCone::IfcRightCircularCone(::Ifc2x3::IfcAxis2Placement3D* v1_Position, double v2_Height, double v3_BottomRadius) : IfcCsgPrimitive3D(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_Position ? v1_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Height));set_attribute_value(2, (v3_BottomRadius));; populate_derived(); }

// Function implementations for IfcRightCircularCylinder
double Ifc2x3::IfcRightCircularCylinder::Height() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcRightCircularCylinder::setHeight(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
double Ifc2x3::IfcRightCircularCylinder::Radius() const {  double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcRightCircularCylinder::setRadius(double v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcRightCircularCylinder::declaration() const { return *((IfcParse::entity*)IFC2X3_types[728]); }
const IfcParse::entity& Ifc2x3::IfcRightCircularCylinder::Class() { return *((IfcParse::entity*)IFC2X3_types[728]); }
Ifc2x3::IfcRightCircularCylinder::IfcRightCircularCylinder(IfcEntityInstanceData&& e) : IfcCsgPrimitive3D(std::move(e)) { }
Ifc2x3::IfcRightCircularCylinder::IfcRightCircularCylinder(::Ifc2x3::IfcAxis2Placement3D* v1_Position, double v2_Height, double v3_Radius) : IfcCsgPrimitive3D(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_Position ? v1_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Height));set_attribute_value(2, (v3_Radius));; populate_derived(); }

// Function implementations for IfcRoof
::Ifc2x3::IfcRoofTypeEnum::Value Ifc2x3::IfcRoof::ShapeType() const {  return ::Ifc2x3::IfcRoofTypeEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcRoof::setShapeType(::Ifc2x3::IfcRoofTypeEnum::Value v) { set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcRoofTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }


const IfcParse::entity& Ifc2x3::IfcRoof::declaration() const { return *((IfcParse::entity*)IFC2X3_types[730]); }
const IfcParse::entity& Ifc2x3::IfcRoof::Class() { return *((IfcParse::entity*)IFC2X3_types[730]); }
Ifc2x3::IfcRoof::IfcRoof(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcRoof::IfcRoof(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, ::Ifc2x3::IfcRoofTypeEnum::Value v9_ShapeType) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcRoofTypeEnum::Class(),(size_t)v9_ShapeType)));; populate_derived(); }

// Function implementations for IfcRoot
std::string Ifc2x3::IfcRoot::GlobalId() const {  std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcRoot::setGlobalId(std::string v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcOwnerHistory* Ifc2x3::IfcRoot::OwnerHistory() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcOwnerHistory>(true); }
void Ifc2x3::IfcRoot::setOwnerHistory(::Ifc2x3::IfcOwnerHistory* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
boost::optional< std::string > Ifc2x3::IfcRoot::Name() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcRoot::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< std::string > Ifc2x3::IfcRoot::Description() const { if(get_attribute_value(3).isNull()) { return boost::none; } std::string v = get_attribute_value(3); return v; }
void Ifc2x3::IfcRoot::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }


const IfcParse::entity& Ifc2x3::IfcRoot::declaration() const { return *((IfcParse::entity*)IFC2X3_types[732]); }
const IfcParse::entity& Ifc2x3::IfcRoot::Class() { return *((IfcParse::entity*)IFC2X3_types[732]); }
Ifc2x3::IfcRoot::IfcRoot(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcRoot::IfcRoot(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }; populate_derived(); }

// Function implementations for IfcRoundedEdgeFeature
boost::optional< double > Ifc2x3::IfcRoundedEdgeFeature::Radius() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcRoundedEdgeFeature::setRadius(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }


const IfcParse::entity& Ifc2x3::IfcRoundedEdgeFeature::declaration() const { return *((IfcParse::entity*)IFC2X3_types[736]); }
const IfcParse::entity& Ifc2x3::IfcRoundedEdgeFeature::Class() { return *((IfcParse::entity*)IFC2X3_types[736]); }
Ifc2x3::IfcRoundedEdgeFeature::IfcRoundedEdgeFeature(IfcEntityInstanceData&& e) : IfcEdgeFeature(std::move(e)) { }
Ifc2x3::IfcRoundedEdgeFeature::IfcRoundedEdgeFeature(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_FeatureLength, boost::optional< double > v10_Radius) : IfcEdgeFeature(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_FeatureLength) {set_attribute_value(8, (*v9_FeatureLength)); } if (v10_Radius) {set_attribute_value(9, (*v10_Radius)); }; populate_derived(); }

// Function implementations for IfcRoundedRectangleProfileDef
double Ifc2x3::IfcRoundedRectangleProfileDef::RoundingRadius() const {  double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcRoundedRectangleProfileDef::setRoundingRadius(double v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcRoundedRectangleProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[737]); }
const IfcParse::entity& Ifc2x3::IfcRoundedRectangleProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[737]); }
Ifc2x3::IfcRoundedRectangleProfileDef::IfcRoundedRectangleProfileDef(IfcEntityInstanceData&& e) : IfcRectangleProfileDef(std::move(e)) { }
Ifc2x3::IfcRoundedRectangleProfileDef::IfcRoundedRectangleProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcAxis2Placement2D* v3_Position, double v4_XDim, double v5_YDim, double v6_RoundingRadius) : IfcRectangleProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_XDim));set_attribute_value(4, (v5_YDim));set_attribute_value(5, (v6_RoundingRadius));; populate_derived(); }

// Function implementations for IfcSIUnit
boost::optional< ::Ifc2x3::IfcSIPrefix::Value > Ifc2x3::IfcSIUnit::Prefix() const { if(get_attribute_value(2).isNull()) { return boost::none; } return ::Ifc2x3::IfcSIPrefix::FromString(get_attribute_value(2)); }
void Ifc2x3::IfcSIUnit::setPrefix(boost::optional< ::Ifc2x3::IfcSIPrefix::Value > v) { if (v) {set_attribute_value(2, EnumerationReference(&::Ifc2x3::IfcSIPrefix::Class(), (size_t) *v));} else {unset_attribute_value(2);} }
::Ifc2x3::IfcSIUnitName::Value Ifc2x3::IfcSIUnit::Name() const {  return ::Ifc2x3::IfcSIUnitName::FromString(get_attribute_value(3)); }
void Ifc2x3::IfcSIUnit::setName(::Ifc2x3::IfcSIUnitName::Value v) { set_attribute_value(3, EnumerationReference(&::Ifc2x3::IfcSIUnitName::Class(), (size_t) v));if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcSIUnit::declaration() const { return *((IfcParse::entity*)IFC2X3_types[765]); }
const IfcParse::entity& Ifc2x3::IfcSIUnit::Class() { return *((IfcParse::entity*)IFC2X3_types[765]); }
Ifc2x3::IfcSIUnit::IfcSIUnit(IfcEntityInstanceData&& e) : IfcNamedUnit(std::move(e)) { }
Ifc2x3::IfcSIUnit::IfcSIUnit(::Ifc2x3::IfcUnitEnum::Value v2_UnitType, boost::optional< ::Ifc2x3::IfcSIPrefix::Value > v3_Prefix, ::Ifc2x3::IfcSIUnitName::Value v4_Name) : IfcNamedUnit(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(1, (EnumerationReference(&::Ifc2x3::IfcUnitEnum::Class(),(size_t)v2_UnitType))); if (v3_Prefix) {set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcSIPrefix::Class(),(size_t)*v3_Prefix))); }set_attribute_value(3, (EnumerationReference(&::Ifc2x3::IfcSIUnitName::Class(),(size_t)v4_Name)));; populate_derived(); }

// Function implementations for IfcSanitaryTerminalType
::Ifc2x3::IfcSanitaryTerminalTypeEnum::Value Ifc2x3::IfcSanitaryTerminalType::PredefinedType() const {  return ::Ifc2x3::IfcSanitaryTerminalTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcSanitaryTerminalType::setPredefinedType(::Ifc2x3::IfcSanitaryTerminalTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcSanitaryTerminalTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcSanitaryTerminalType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[738]); }
const IfcParse::entity& Ifc2x3::IfcSanitaryTerminalType::Class() { return *((IfcParse::entity*)IFC2X3_types[738]); }
Ifc2x3::IfcSanitaryTerminalType::IfcSanitaryTerminalType(IfcEntityInstanceData&& e) : IfcFlowTerminalType(std::move(e)) { }
Ifc2x3::IfcSanitaryTerminalType::IfcSanitaryTerminalType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcSanitaryTerminalTypeEnum::Value v10_PredefinedType) : IfcFlowTerminalType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcSanitaryTerminalTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcScheduleTimeControl
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcScheduleTimeControl::ActualStart() const { if(get_attribute_value(5).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcScheduleTimeControl::setActualStart(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcScheduleTimeControl::EarlyStart() const { if(get_attribute_value(6).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcScheduleTimeControl::setEarlyStart(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcScheduleTimeControl::LateStart() const { if(get_attribute_value(7).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(7)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcScheduleTimeControl::setLateStart(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(7, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(7); }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcScheduleTimeControl::ScheduleStart() const { if(get_attribute_value(8).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(8)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcScheduleTimeControl::setScheduleStart(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(8, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(8); }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcScheduleTimeControl::ActualFinish() const { if(get_attribute_value(9).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(9)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcScheduleTimeControl::setActualFinish(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(9, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(9); }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcScheduleTimeControl::EarlyFinish() const { if(get_attribute_value(10).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(10)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcScheduleTimeControl::setEarlyFinish(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(10, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(10); }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcScheduleTimeControl::LateFinish() const { if(get_attribute_value(11).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(11)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcScheduleTimeControl::setLateFinish(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(11, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(11); }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcScheduleTimeControl::ScheduleFinish() const { if(get_attribute_value(12).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(12)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcScheduleTimeControl::setScheduleFinish(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(12, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(12); }
boost::optional< double > Ifc2x3::IfcScheduleTimeControl::ScheduleDuration() const { if(get_attribute_value(13).isNull()) { return boost::none; } double v = get_attribute_value(13); return v; }
void Ifc2x3::IfcScheduleTimeControl::setScheduleDuration(boost::optional< double > v) { if (v) {set_attribute_value(13, *v);} else {unset_attribute_value(13);} }
boost::optional< double > Ifc2x3::IfcScheduleTimeControl::ActualDuration() const { if(get_attribute_value(14).isNull()) { return boost::none; } double v = get_attribute_value(14); return v; }
void Ifc2x3::IfcScheduleTimeControl::setActualDuration(boost::optional< double > v) { if (v) {set_attribute_value(14, *v);} else {unset_attribute_value(14);} }
boost::optional< double > Ifc2x3::IfcScheduleTimeControl::RemainingTime() const { if(get_attribute_value(15).isNull()) { return boost::none; } double v = get_attribute_value(15); return v; }
void Ifc2x3::IfcScheduleTimeControl::setRemainingTime(boost::optional< double > v) { if (v) {set_attribute_value(15, *v);} else {unset_attribute_value(15);} }
boost::optional< double > Ifc2x3::IfcScheduleTimeControl::FreeFloat() const { if(get_attribute_value(16).isNull()) { return boost::none; } double v = get_attribute_value(16); return v; }
void Ifc2x3::IfcScheduleTimeControl::setFreeFloat(boost::optional< double > v) { if (v) {set_attribute_value(16, *v);} else {unset_attribute_value(16);} }
boost::optional< double > Ifc2x3::IfcScheduleTimeControl::TotalFloat() const { if(get_attribute_value(17).isNull()) { return boost::none; } double v = get_attribute_value(17); return v; }
void Ifc2x3::IfcScheduleTimeControl::setTotalFloat(boost::optional< double > v) { if (v) {set_attribute_value(17, *v);} else {unset_attribute_value(17);} }
boost::optional< bool > Ifc2x3::IfcScheduleTimeControl::IsCritical() const { if(get_attribute_value(18).isNull()) { return boost::none; } bool v = get_attribute_value(18); return v; }
void Ifc2x3::IfcScheduleTimeControl::setIsCritical(boost::optional< bool > v) { if (v) {set_attribute_value(18, *v);} else {unset_attribute_value(18);} }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcScheduleTimeControl::StatusTime() const { if(get_attribute_value(19).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(19)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcScheduleTimeControl::setStatusTime(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(19, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(19); }
boost::optional< double > Ifc2x3::IfcScheduleTimeControl::StartFloat() const { if(get_attribute_value(20).isNull()) { return boost::none; } double v = get_attribute_value(20); return v; }
void Ifc2x3::IfcScheduleTimeControl::setStartFloat(boost::optional< double > v) { if (v) {set_attribute_value(20, *v);} else {unset_attribute_value(20);} }
boost::optional< double > Ifc2x3::IfcScheduleTimeControl::FinishFloat() const { if(get_attribute_value(21).isNull()) { return boost::none; } double v = get_attribute_value(21); return v; }
void Ifc2x3::IfcScheduleTimeControl::setFinishFloat(boost::optional< double > v) { if (v) {set_attribute_value(21, *v);} else {unset_attribute_value(21);} }
boost::optional< double > Ifc2x3::IfcScheduleTimeControl::Completion() const { if(get_attribute_value(22).isNull()) { return boost::none; } double v = get_attribute_value(22); return v; }
void Ifc2x3::IfcScheduleTimeControl::setCompletion(boost::optional< double > v) { if (v) {set_attribute_value(22, *v);} else {unset_attribute_value(22);} }

::Ifc2x3::IfcRelAssignsTasks::list::ptr Ifc2x3::IfcScheduleTimeControl::ScheduleTimeControlAssigned() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[669], 7)->as<IfcRelAssignsTasks>(); }

const IfcParse::entity& Ifc2x3::IfcScheduleTimeControl::declaration() const { return *((IfcParse::entity*)IFC2X3_types[740]); }
const IfcParse::entity& Ifc2x3::IfcScheduleTimeControl::Class() { return *((IfcParse::entity*)IFC2X3_types[740]); }
Ifc2x3::IfcScheduleTimeControl::IfcScheduleTimeControl(IfcEntityInstanceData&& e) : IfcControl(std::move(e)) { }
Ifc2x3::IfcScheduleTimeControl::IfcScheduleTimeControl(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcDateTimeSelect* v6_ActualStart, ::Ifc2x3::IfcDateTimeSelect* v7_EarlyStart, ::Ifc2x3::IfcDateTimeSelect* v8_LateStart, ::Ifc2x3::IfcDateTimeSelect* v9_ScheduleStart, ::Ifc2x3::IfcDateTimeSelect* v10_ActualFinish, ::Ifc2x3::IfcDateTimeSelect* v11_EarlyFinish, ::Ifc2x3::IfcDateTimeSelect* v12_LateFinish, ::Ifc2x3::IfcDateTimeSelect* v13_ScheduleFinish, boost::optional< double > v14_ScheduleDuration, boost::optional< double > v15_ActualDuration, boost::optional< double > v16_RemainingTime, boost::optional< double > v17_FreeFloat, boost::optional< double > v18_TotalFloat, boost::optional< bool > v19_IsCritical, ::Ifc2x3::IfcDateTimeSelect* v20_StatusTime, boost::optional< double > v21_StartFloat, boost::optional< double > v22_FinishFloat, boost::optional< double > v23_Completion) : IfcControl(IfcEntityInstanceData(in_memory_attribute_storage(23))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ActualStart ? v6_ActualStart->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_EarlyStart ? v7_EarlyStart->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_LateStart ? v8_LateStart->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(8, v9_ScheduleStart ? v9_ScheduleStart->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(9, v10_ActualFinish ? v10_ActualFinish->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(10, v11_EarlyFinish ? v11_EarlyFinish->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(11, v12_LateFinish ? v12_LateFinish->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(12, v13_ScheduleFinish ? v13_ScheduleFinish->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v14_ScheduleDuration) {set_attribute_value(13, (*v14_ScheduleDuration)); } if (v15_ActualDuration) {set_attribute_value(14, (*v15_ActualDuration)); } if (v16_RemainingTime) {set_attribute_value(15, (*v16_RemainingTime)); } if (v17_FreeFloat) {set_attribute_value(16, (*v17_FreeFloat)); } if (v18_TotalFloat) {set_attribute_value(17, (*v18_TotalFloat)); } if (v19_IsCritical) {set_attribute_value(18, (*v19_IsCritical)); }set_attribute_value(19, v20_StatusTime ? v20_StatusTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v21_StartFloat) {set_attribute_value(20, (*v21_StartFloat)); } if (v22_FinishFloat) {set_attribute_value(21, (*v22_FinishFloat)); } if (v23_Completion) {set_attribute_value(22, (*v23_Completion)); }; populate_derived(); }

// Function implementations for IfcSectionProperties
::Ifc2x3::IfcSectionTypeEnum::Value Ifc2x3::IfcSectionProperties::SectionType() const {  return ::Ifc2x3::IfcSectionTypeEnum::FromString(get_attribute_value(0)); }
void Ifc2x3::IfcSectionProperties::setSectionType(::Ifc2x3::IfcSectionTypeEnum::Value v) { set_attribute_value(0, EnumerationReference(&::Ifc2x3::IfcSectionTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcProfileDef* Ifc2x3::IfcSectionProperties::StartProfile() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcProfileDef>(true); }
void Ifc2x3::IfcSectionProperties::setStartProfile(::Ifc2x3::IfcProfileDef* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcProfileDef* Ifc2x3::IfcSectionProperties::EndProfile() const { if(get_attribute_value(2).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcProfileDef>(true); }
void Ifc2x3::IfcSectionProperties::setEndProfile(::Ifc2x3::IfcProfileDef* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcSectionProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[745]); }
const IfcParse::entity& Ifc2x3::IfcSectionProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[745]); }
Ifc2x3::IfcSectionProperties::IfcSectionProperties(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcSectionProperties::IfcSectionProperties(::Ifc2x3::IfcSectionTypeEnum::Value v1_SectionType, ::Ifc2x3::IfcProfileDef* v2_StartProfile, ::Ifc2x3::IfcProfileDef* v3_EndProfile) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcSectionTypeEnum::Class(),(size_t)v1_SectionType)));set_attribute_value(1, v2_StartProfile ? v2_StartProfile->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_EndProfile ? v3_EndProfile->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcSectionReinforcementProperties
double Ifc2x3::IfcSectionReinforcementProperties::LongitudinalStartPosition() const {  double v = get_attribute_value(0); return v; }
void Ifc2x3::IfcSectionReinforcementProperties::setLongitudinalStartPosition(double v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
double Ifc2x3::IfcSectionReinforcementProperties::LongitudinalEndPosition() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcSectionReinforcementProperties::setLongitudinalEndPosition(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
boost::optional< double > Ifc2x3::IfcSectionReinforcementProperties::TransversePosition() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcSectionReinforcementProperties::setTransversePosition(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
::Ifc2x3::IfcReinforcingBarRoleEnum::Value Ifc2x3::IfcSectionReinforcementProperties::ReinforcementRole() const {  return ::Ifc2x3::IfcReinforcingBarRoleEnum::FromString(get_attribute_value(3)); }
void Ifc2x3::IfcSectionReinforcementProperties::setReinforcementRole(::Ifc2x3::IfcReinforcingBarRoleEnum::Value v) { set_attribute_value(3, EnumerationReference(&::Ifc2x3::IfcReinforcingBarRoleEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(3); }
::Ifc2x3::IfcSectionProperties* Ifc2x3::IfcSectionReinforcementProperties::SectionDefinition() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcSectionProperties>(true); }
void Ifc2x3::IfcSectionReinforcementProperties::setSectionDefinition(::Ifc2x3::IfcSectionProperties* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
aggregate_of< ::Ifc2x3::IfcReinforcementBarProperties >::ptr Ifc2x3::IfcSectionReinforcementProperties::CrossSectionReinforcementDefinitions() const {  aggregate_of_instance::ptr es = get_attribute_value(5); return es->as< ::Ifc2x3::IfcReinforcementBarProperties >(); }
void Ifc2x3::IfcSectionReinforcementProperties::setCrossSectionReinforcementDefinitions(aggregate_of< ::Ifc2x3::IfcReinforcementBarProperties >::ptr v) { set_attribute_value(5, (v)->generalize());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcSectionReinforcementProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[746]); }
const IfcParse::entity& Ifc2x3::IfcSectionReinforcementProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[746]); }
Ifc2x3::IfcSectionReinforcementProperties::IfcSectionReinforcementProperties(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcSectionReinforcementProperties::IfcSectionReinforcementProperties(double v1_LongitudinalStartPosition, double v2_LongitudinalEndPosition, boost::optional< double > v3_TransversePosition, ::Ifc2x3::IfcReinforcingBarRoleEnum::Value v4_ReinforcementRole, ::Ifc2x3::IfcSectionProperties* v5_SectionDefinition, aggregate_of< ::Ifc2x3::IfcReinforcementBarProperties >::ptr v6_CrossSectionReinforcementDefinitions) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_LongitudinalStartPosition));set_attribute_value(1, (v2_LongitudinalEndPosition)); if (v3_TransversePosition) {set_attribute_value(2, (*v3_TransversePosition)); }set_attribute_value(3, (EnumerationReference(&::Ifc2x3::IfcReinforcingBarRoleEnum::Class(),(size_t)v4_ReinforcementRole)));set_attribute_value(4, v5_SectionDefinition ? v5_SectionDefinition->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, (v6_CrossSectionReinforcementDefinitions)->generalize());; populate_derived(); }

// Function implementations for IfcSectionedSpine
::Ifc2x3::IfcCompositeCurve* Ifc2x3::IfcSectionedSpine::SpineCurve() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcCompositeCurve>(true); }
void Ifc2x3::IfcSectionedSpine::setSpineCurve(::Ifc2x3::IfcCompositeCurve* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcProfileDef >::ptr Ifc2x3::IfcSectionedSpine::CrossSections() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcProfileDef >(); }
void Ifc2x3::IfcSectionedSpine::setCrossSections(aggregate_of< ::Ifc2x3::IfcProfileDef >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }
aggregate_of< ::Ifc2x3::IfcAxis2Placement3D >::ptr Ifc2x3::IfcSectionedSpine::CrossSectionPositions() const {  aggregate_of_instance::ptr es = get_attribute_value(2); return es->as< ::Ifc2x3::IfcAxis2Placement3D >(); }
void Ifc2x3::IfcSectionedSpine::setCrossSectionPositions(aggregate_of< ::Ifc2x3::IfcAxis2Placement3D >::ptr v) { set_attribute_value(2, (v)->generalize());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcSectionedSpine::declaration() const { return *((IfcParse::entity*)IFC2X3_types[743]); }
const IfcParse::entity& Ifc2x3::IfcSectionedSpine::Class() { return *((IfcParse::entity*)IFC2X3_types[743]); }
Ifc2x3::IfcSectionedSpine::IfcSectionedSpine(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcSectionedSpine::IfcSectionedSpine(::Ifc2x3::IfcCompositeCurve* v1_SpineCurve, aggregate_of< ::Ifc2x3::IfcProfileDef >::ptr v2_CrossSections, aggregate_of< ::Ifc2x3::IfcAxis2Placement3D >::ptr v3_CrossSectionPositions) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_SpineCurve ? v1_SpineCurve->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_CrossSections)->generalize());set_attribute_value(2, (v3_CrossSectionPositions)->generalize());; populate_derived(); }

// Function implementations for IfcSensorType
::Ifc2x3::IfcSensorTypeEnum::Value Ifc2x3::IfcSensorType::PredefinedType() const {  return ::Ifc2x3::IfcSensorTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcSensorType::setPredefinedType(::Ifc2x3::IfcSensorTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcSensorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcSensorType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[748]); }
const IfcParse::entity& Ifc2x3::IfcSensorType::Class() { return *((IfcParse::entity*)IFC2X3_types[748]); }
Ifc2x3::IfcSensorType::IfcSensorType(IfcEntityInstanceData&& e) : IfcDistributionControlElementType(std::move(e)) { }
Ifc2x3::IfcSensorType::IfcSensorType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcSensorTypeEnum::Value v10_PredefinedType) : IfcDistributionControlElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcSensorTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcServiceLife
::Ifc2x3::IfcServiceLifeTypeEnum::Value Ifc2x3::IfcServiceLife::ServiceLifeType() const {  return ::Ifc2x3::IfcServiceLifeTypeEnum::FromString(get_attribute_value(5)); }
void Ifc2x3::IfcServiceLife::setServiceLifeType(::Ifc2x3::IfcServiceLifeTypeEnum::Value v) { set_attribute_value(5, EnumerationReference(&::Ifc2x3::IfcServiceLifeTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(5); }
double Ifc2x3::IfcServiceLife::ServiceLifeDuration() const {  double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcServiceLife::setServiceLifeDuration(double v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcServiceLife::declaration() const { return *((IfcParse::entity*)IFC2X3_types[751]); }
const IfcParse::entity& Ifc2x3::IfcServiceLife::Class() { return *((IfcParse::entity*)IFC2X3_types[751]); }
Ifc2x3::IfcServiceLife::IfcServiceLife(IfcEntityInstanceData&& e) : IfcControl(std::move(e)) { }
Ifc2x3::IfcServiceLife::IfcServiceLife(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcServiceLifeTypeEnum::Value v6_ServiceLifeType, double v7_ServiceLifeDuration) : IfcControl(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcServiceLifeTypeEnum::Class(),(size_t)v6_ServiceLifeType)));set_attribute_value(6, (v7_ServiceLifeDuration));; populate_derived(); }

// Function implementations for IfcServiceLifeFactor
::Ifc2x3::IfcServiceLifeFactorTypeEnum::Value Ifc2x3::IfcServiceLifeFactor::PredefinedType() const {  return ::Ifc2x3::IfcServiceLifeFactorTypeEnum::FromString(get_attribute_value(4)); }
void Ifc2x3::IfcServiceLifeFactor::setPredefinedType(::Ifc2x3::IfcServiceLifeFactorTypeEnum::Value v) { set_attribute_value(4, EnumerationReference(&::Ifc2x3::IfcServiceLifeFactorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcMeasureValue* Ifc2x3::IfcServiceLifeFactor::UpperValue() const { if(get_attribute_value(5).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcMeasureValue>(true); }
void Ifc2x3::IfcServiceLifeFactor::setUpperValue(::Ifc2x3::IfcMeasureValue* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcMeasureValue* Ifc2x3::IfcServiceLifeFactor::MostUsedValue() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcMeasureValue>(true); }
void Ifc2x3::IfcServiceLifeFactor::setMostUsedValue(::Ifc2x3::IfcMeasureValue* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
::Ifc2x3::IfcMeasureValue* Ifc2x3::IfcServiceLifeFactor::LowerValue() const { if(get_attribute_value(7).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(7)))->as<::Ifc2x3::IfcMeasureValue>(true); }
void Ifc2x3::IfcServiceLifeFactor::setLowerValue(::Ifc2x3::IfcMeasureValue* v) { set_attribute_value(7, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(7); }


const IfcParse::entity& Ifc2x3::IfcServiceLifeFactor::declaration() const { return *((IfcParse::entity*)IFC2X3_types[752]); }
const IfcParse::entity& Ifc2x3::IfcServiceLifeFactor::Class() { return *((IfcParse::entity*)IFC2X3_types[752]); }
Ifc2x3::IfcServiceLifeFactor::IfcServiceLifeFactor(IfcEntityInstanceData&& e) : IfcPropertySetDefinition(std::move(e)) { }
Ifc2x3::IfcServiceLifeFactor::IfcServiceLifeFactor(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcServiceLifeFactorTypeEnum::Value v5_PredefinedType, ::Ifc2x3::IfcMeasureValue* v6_UpperValue, ::Ifc2x3::IfcMeasureValue* v7_MostUsedValue, ::Ifc2x3::IfcMeasureValue* v8_LowerValue) : IfcPropertySetDefinition(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (EnumerationReference(&::Ifc2x3::IfcServiceLifeFactorTypeEnum::Class(),(size_t)v5_PredefinedType)));set_attribute_value(5, v6_UpperValue ? v6_UpperValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_MostUsedValue ? v7_MostUsedValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_LowerValue ? v8_LowerValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcShapeAspect
aggregate_of< ::Ifc2x3::IfcShapeModel >::ptr Ifc2x3::IfcShapeAspect::ShapeRepresentations() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcShapeModel >(); }
void Ifc2x3::IfcShapeAspect::setShapeRepresentations(aggregate_of< ::Ifc2x3::IfcShapeModel >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }
boost::optional< std::string > Ifc2x3::IfcShapeAspect::Name() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcShapeAspect::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< std::string > Ifc2x3::IfcShapeAspect::Description() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcShapeAspect::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::logic::tribool Ifc2x3::IfcShapeAspect::ProductDefinitional() const {  boost::logic::tribool v = get_attribute_value(3); return v; }
void Ifc2x3::IfcShapeAspect::setProductDefinitional(boost::logic::tribool v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
::Ifc2x3::IfcProductDefinitionShape* Ifc2x3::IfcShapeAspect::PartOfProductDefinitionShape() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcProductDefinitionShape>(true); }
void Ifc2x3::IfcShapeAspect::setPartOfProductDefinitionShape(::Ifc2x3::IfcProductDefinitionShape* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcShapeAspect::declaration() const { return *((IfcParse::entity*)IFC2X3_types[755]); }
const IfcParse::entity& Ifc2x3::IfcShapeAspect::Class() { return *((IfcParse::entity*)IFC2X3_types[755]); }
Ifc2x3::IfcShapeAspect::IfcShapeAspect(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcShapeAspect::IfcShapeAspect(aggregate_of< ::Ifc2x3::IfcShapeModel >::ptr v1_ShapeRepresentations, boost::optional< std::string > v2_Name, boost::optional< std::string > v3_Description, boost::logic::tribool v4_ProductDefinitional, ::Ifc2x3::IfcProductDefinitionShape* v5_PartOfProductDefinitionShape) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_ShapeRepresentations)->generalize()); if (v2_Name) {set_attribute_value(1, (*v2_Name)); } if (v3_Description) {set_attribute_value(2, (*v3_Description)); }set_attribute_value(3, (v4_ProductDefinitional));set_attribute_value(4, v5_PartOfProductDefinitionShape ? v5_PartOfProductDefinitionShape->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcShapeModel

::Ifc2x3::IfcShapeAspect::list::ptr Ifc2x3::IfcShapeModel::OfShapeAspect() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[755], 0)->as<IfcShapeAspect>(); }

const IfcParse::entity& Ifc2x3::IfcShapeModel::declaration() const { return *((IfcParse::entity*)IFC2X3_types[756]); }
const IfcParse::entity& Ifc2x3::IfcShapeModel::Class() { return *((IfcParse::entity*)IFC2X3_types[756]); }
Ifc2x3::IfcShapeModel::IfcShapeModel(IfcEntityInstanceData&& e) : IfcRepresentation(std::move(e)) { }
Ifc2x3::IfcShapeModel::IfcShapeModel(::Ifc2x3::IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, aggregate_of< ::Ifc2x3::IfcRepresentationItem >::ptr v4_Items) : IfcRepresentation(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_ContextOfItems ? v1_ContextOfItems->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_RepresentationIdentifier) {set_attribute_value(1, (*v2_RepresentationIdentifier)); } if (v3_RepresentationType) {set_attribute_value(2, (*v3_RepresentationType)); }set_attribute_value(3, (v4_Items)->generalize());; populate_derived(); }

// Function implementations for IfcShapeRepresentation


const IfcParse::entity& Ifc2x3::IfcShapeRepresentation::declaration() const { return *((IfcParse::entity*)IFC2X3_types[757]); }
const IfcParse::entity& Ifc2x3::IfcShapeRepresentation::Class() { return *((IfcParse::entity*)IFC2X3_types[757]); }
Ifc2x3::IfcShapeRepresentation::IfcShapeRepresentation(IfcEntityInstanceData&& e) : IfcShapeModel(std::move(e)) { }
Ifc2x3::IfcShapeRepresentation::IfcShapeRepresentation(::Ifc2x3::IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, aggregate_of< ::Ifc2x3::IfcRepresentationItem >::ptr v4_Items) : IfcShapeModel(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_ContextOfItems ? v1_ContextOfItems->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_RepresentationIdentifier) {set_attribute_value(1, (*v2_RepresentationIdentifier)); } if (v3_RepresentationType) {set_attribute_value(2, (*v3_RepresentationType)); }set_attribute_value(3, (v4_Items)->generalize());; populate_derived(); }

// Function implementations for IfcShellBasedSurfaceModel
aggregate_of< ::Ifc2x3::IfcShell >::ptr Ifc2x3::IfcShellBasedSurfaceModel::SbsmBoundary() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcShell >(); }
void Ifc2x3::IfcShellBasedSurfaceModel::setSbsmBoundary(aggregate_of< ::Ifc2x3::IfcShell >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcShellBasedSurfaceModel::declaration() const { return *((IfcParse::entity*)IFC2X3_types[760]); }
const IfcParse::entity& Ifc2x3::IfcShellBasedSurfaceModel::Class() { return *((IfcParse::entity*)IFC2X3_types[760]); }
Ifc2x3::IfcShellBasedSurfaceModel::IfcShellBasedSurfaceModel(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcShellBasedSurfaceModel::IfcShellBasedSurfaceModel(aggregate_of< ::Ifc2x3::IfcShell >::ptr v1_SbsmBoundary) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_SbsmBoundary)->generalize());; populate_derived(); }

// Function implementations for IfcSimpleProperty


const IfcParse::entity& Ifc2x3::IfcSimpleProperty::declaration() const { return *((IfcParse::entity*)IFC2X3_types[761]); }
const IfcParse::entity& Ifc2x3::IfcSimpleProperty::Class() { return *((IfcParse::entity*)IFC2X3_types[761]); }
Ifc2x3::IfcSimpleProperty::IfcSimpleProperty(IfcEntityInstanceData&& e) : IfcProperty(std::move(e)) { }
Ifc2x3::IfcSimpleProperty::IfcSimpleProperty(std::string v1_Name, boost::optional< std::string > v2_Description) : IfcProperty(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }; populate_derived(); }

// Function implementations for IfcSite
boost::optional< std::vector< int > /*[3:4]*/ > Ifc2x3::IfcSite::RefLatitude() const { if(get_attribute_value(9).isNull()) { return boost::none; } std::vector< int > /*[3:4]*/ v = get_attribute_value(9); return v; }
void Ifc2x3::IfcSite::setRefLatitude(boost::optional< std::vector< int > /*[3:4]*/ > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
boost::optional< std::vector< int > /*[3:4]*/ > Ifc2x3::IfcSite::RefLongitude() const { if(get_attribute_value(10).isNull()) { return boost::none; } std::vector< int > /*[3:4]*/ v = get_attribute_value(10); return v; }
void Ifc2x3::IfcSite::setRefLongitude(boost::optional< std::vector< int > /*[3:4]*/ > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
boost::optional< double > Ifc2x3::IfcSite::RefElevation() const { if(get_attribute_value(11).isNull()) { return boost::none; } double v = get_attribute_value(11); return v; }
void Ifc2x3::IfcSite::setRefElevation(boost::optional< double > v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
boost::optional< std::string > Ifc2x3::IfcSite::LandTitleNumber() const { if(get_attribute_value(12).isNull()) { return boost::none; } std::string v = get_attribute_value(12); return v; }
void Ifc2x3::IfcSite::setLandTitleNumber(boost::optional< std::string > v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
::Ifc2x3::IfcPostalAddress* Ifc2x3::IfcSite::SiteAddress() const { if(get_attribute_value(13).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(13)))->as<::Ifc2x3::IfcPostalAddress>(true); }
void Ifc2x3::IfcSite::setSiteAddress(::Ifc2x3::IfcPostalAddress* v) { set_attribute_value(13, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(13); }


const IfcParse::entity& Ifc2x3::IfcSite::declaration() const { return *((IfcParse::entity*)IFC2X3_types[764]); }
const IfcParse::entity& Ifc2x3::IfcSite::Class() { return *((IfcParse::entity*)IFC2X3_types[764]); }
Ifc2x3::IfcSite::IfcSite(IfcEntityInstanceData&& e) : IfcSpatialStructureElement(std::move(e)) { }
Ifc2x3::IfcSite::IfcSite(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, ::Ifc2x3::IfcElementCompositionEnum::Value v9_CompositionType, boost::optional< std::vector< int > /*[3:4]*/ > v10_RefLatitude, boost::optional< std::vector< int > /*[3:4]*/ > v11_RefLongitude, boost::optional< double > v12_RefElevation, boost::optional< std::string > v13_LandTitleNumber, ::Ifc2x3::IfcPostalAddress* v14_SiteAddress) : IfcSpatialStructureElement(IfcEntityInstanceData(in_memory_attribute_storage(14))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_LongName) {set_attribute_value(7, (*v8_LongName)); }set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcElementCompositionEnum::Class(),(size_t)v9_CompositionType))); if (v10_RefLatitude) {set_attribute_value(9, (*v10_RefLatitude)); } if (v11_RefLongitude) {set_attribute_value(10, (*v11_RefLongitude)); } if (v12_RefElevation) {set_attribute_value(11, (*v12_RefElevation)); } if (v13_LandTitleNumber) {set_attribute_value(12, (*v13_LandTitleNumber)); }set_attribute_value(13, v14_SiteAddress ? v14_SiteAddress->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcSlab
boost::optional< ::Ifc2x3::IfcSlabTypeEnum::Value > Ifc2x3::IfcSlab::PredefinedType() const { if(get_attribute_value(8).isNull()) { return boost::none; } return ::Ifc2x3::IfcSlabTypeEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcSlab::setPredefinedType(boost::optional< ::Ifc2x3::IfcSlabTypeEnum::Value > v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcSlabTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }


const IfcParse::entity& Ifc2x3::IfcSlab::declaration() const { return *((IfcParse::entity*)IFC2X3_types[768]); }
const IfcParse::entity& Ifc2x3::IfcSlab::Class() { return *((IfcParse::entity*)IFC2X3_types[768]); }
Ifc2x3::IfcSlab::IfcSlab(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcSlab::IfcSlab(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< ::Ifc2x3::IfcSlabTypeEnum::Value > v9_PredefinedType) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcSlabTypeEnum::Class(),(size_t)*v9_PredefinedType))); }; populate_derived(); }

// Function implementations for IfcSlabType
::Ifc2x3::IfcSlabTypeEnum::Value Ifc2x3::IfcSlabType::PredefinedType() const {  return ::Ifc2x3::IfcSlabTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcSlabType::setPredefinedType(::Ifc2x3::IfcSlabTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcSlabTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcSlabType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[769]); }
const IfcParse::entity& Ifc2x3::IfcSlabType::Class() { return *((IfcParse::entity*)IFC2X3_types[769]); }
Ifc2x3::IfcSlabType::IfcSlabType(IfcEntityInstanceData&& e) : IfcBuildingElementType(std::move(e)) { }
Ifc2x3::IfcSlabType::IfcSlabType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcSlabTypeEnum::Value v10_PredefinedType) : IfcBuildingElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcSlabTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcSlippageConnectionCondition
boost::optional< double > Ifc2x3::IfcSlippageConnectionCondition::SlippageX() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcSlippageConnectionCondition::setSlippageX(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcSlippageConnectionCondition::SlippageY() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcSlippageConnectionCondition::setSlippageY(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcSlippageConnectionCondition::SlippageZ() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcSlippageConnectionCondition::setSlippageZ(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }


const IfcParse::entity& Ifc2x3::IfcSlippageConnectionCondition::declaration() const { return *((IfcParse::entity*)IFC2X3_types[771]); }
const IfcParse::entity& Ifc2x3::IfcSlippageConnectionCondition::Class() { return *((IfcParse::entity*)IFC2X3_types[771]); }
Ifc2x3::IfcSlippageConnectionCondition::IfcSlippageConnectionCondition(IfcEntityInstanceData&& e) : IfcStructuralConnectionCondition(std::move(e)) { }
Ifc2x3::IfcSlippageConnectionCondition::IfcSlippageConnectionCondition(boost::optional< std::string > v1_Name, boost::optional< double > v2_SlippageX, boost::optional< double > v3_SlippageY, boost::optional< double > v4_SlippageZ) : IfcStructuralConnectionCondition(IfcEntityInstanceData(in_memory_attribute_storage(4))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_SlippageX) {set_attribute_value(1, (*v2_SlippageX)); } if (v3_SlippageY) {set_attribute_value(2, (*v3_SlippageY)); } if (v4_SlippageZ) {set_attribute_value(3, (*v4_SlippageZ)); }; populate_derived(); }

// Function implementations for IfcSolidModel


const IfcParse::entity& Ifc2x3::IfcSolidModel::declaration() const { return *((IfcParse::entity*)IFC2X3_types[773]); }
const IfcParse::entity& Ifc2x3::IfcSolidModel::Class() { return *((IfcParse::entity*)IFC2X3_types[773]); }
Ifc2x3::IfcSolidModel::IfcSolidModel(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcSolidModel::IfcSolidModel() : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(0))) { ; populate_derived(); }

// Function implementations for IfcSoundProperties
bool Ifc2x3::IfcSoundProperties::IsAttenuating() const {  bool v = get_attribute_value(4); return v; }
void Ifc2x3::IfcSoundProperties::setIsAttenuating(bool v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
boost::optional< ::Ifc2x3::IfcSoundScaleEnum::Value > Ifc2x3::IfcSoundProperties::SoundScale() const { if(get_attribute_value(5).isNull()) { return boost::none; } return ::Ifc2x3::IfcSoundScaleEnum::FromString(get_attribute_value(5)); }
void Ifc2x3::IfcSoundProperties::setSoundScale(boost::optional< ::Ifc2x3::IfcSoundScaleEnum::Value > v) { if (v) {set_attribute_value(5, EnumerationReference(&::Ifc2x3::IfcSoundScaleEnum::Class(), (size_t) *v));} else {unset_attribute_value(5);} }
aggregate_of< ::Ifc2x3::IfcSoundValue >::ptr Ifc2x3::IfcSoundProperties::SoundValues() const {  aggregate_of_instance::ptr es = get_attribute_value(6); return es->as< ::Ifc2x3::IfcSoundValue >(); }
void Ifc2x3::IfcSoundProperties::setSoundValues(aggregate_of< ::Ifc2x3::IfcSoundValue >::ptr v) { set_attribute_value(6, (v)->generalize());if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcSoundProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[776]); }
const IfcParse::entity& Ifc2x3::IfcSoundProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[776]); }
Ifc2x3::IfcSoundProperties::IfcSoundProperties(IfcEntityInstanceData&& e) : IfcPropertySetDefinition(std::move(e)) { }
Ifc2x3::IfcSoundProperties::IfcSoundProperties(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, bool v5_IsAttenuating, boost::optional< ::Ifc2x3::IfcSoundScaleEnum::Value > v6_SoundScale, aggregate_of< ::Ifc2x3::IfcSoundValue >::ptr v7_SoundValues) : IfcPropertySetDefinition(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_IsAttenuating)); if (v6_SoundScale) {set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcSoundScaleEnum::Class(),(size_t)*v6_SoundScale))); }set_attribute_value(6, (v7_SoundValues)->generalize());; populate_derived(); }

// Function implementations for IfcSoundValue
::Ifc2x3::IfcTimeSeries* Ifc2x3::IfcSoundValue::SoundLevelTimeSeries() const { if(get_attribute_value(4).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcTimeSeries>(true); }
void Ifc2x3::IfcSoundValue::setSoundLevelTimeSeries(::Ifc2x3::IfcTimeSeries* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
double Ifc2x3::IfcSoundValue::Frequency() const {  double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcSoundValue::setFrequency(double v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcDerivedMeasureValue* Ifc2x3::IfcSoundValue::SoundLevelSingleValue() const { if(get_attribute_value(6).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcDerivedMeasureValue>(true); }
void Ifc2x3::IfcSoundValue::setSoundLevelSingleValue(::Ifc2x3::IfcDerivedMeasureValue* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcSoundValue::declaration() const { return *((IfcParse::entity*)IFC2X3_types[778]); }
const IfcParse::entity& Ifc2x3::IfcSoundValue::Class() { return *((IfcParse::entity*)IFC2X3_types[778]); }
Ifc2x3::IfcSoundValue::IfcSoundValue(IfcEntityInstanceData&& e) : IfcPropertySetDefinition(std::move(e)) { }
Ifc2x3::IfcSoundValue::IfcSoundValue(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcTimeSeries* v5_SoundLevelTimeSeries, double v6_Frequency, ::Ifc2x3::IfcDerivedMeasureValue* v7_SoundLevelSingleValue) : IfcPropertySetDefinition(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, v5_SoundLevelTimeSeries ? v5_SoundLevelTimeSeries->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, (v6_Frequency));set_attribute_value(6, v7_SoundLevelSingleValue ? v7_SoundLevelSingleValue->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcSpace
::Ifc2x3::IfcInternalOrExternalEnum::Value Ifc2x3::IfcSpace::InteriorOrExteriorSpace() const {  return ::Ifc2x3::IfcInternalOrExternalEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcSpace::setInteriorOrExteriorSpace(::Ifc2x3::IfcInternalOrExternalEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcInternalOrExternalEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
boost::optional< double > Ifc2x3::IfcSpace::ElevationWithFlooring() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcSpace::setElevationWithFlooring(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }

::Ifc2x3::IfcRelCoversSpaces::list::ptr Ifc2x3::IfcSpace::HasCoverings() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[700], 4)->as<IfcRelCoversSpaces>(); }
::Ifc2x3::IfcRelSpaceBoundary::list::ptr Ifc2x3::IfcSpace::BoundedBy() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[716], 4)->as<IfcRelSpaceBoundary>(); }

const IfcParse::entity& Ifc2x3::IfcSpace::declaration() const { return *((IfcParse::entity*)IFC2X3_types[779]); }
const IfcParse::entity& Ifc2x3::IfcSpace::Class() { return *((IfcParse::entity*)IFC2X3_types[779]); }
Ifc2x3::IfcSpace::IfcSpace(IfcEntityInstanceData&& e) : IfcSpatialStructureElement(std::move(e)) { }
Ifc2x3::IfcSpace::IfcSpace(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, ::Ifc2x3::IfcElementCompositionEnum::Value v9_CompositionType, ::Ifc2x3::IfcInternalOrExternalEnum::Value v10_InteriorOrExteriorSpace, boost::optional< double > v11_ElevationWithFlooring) : IfcSpatialStructureElement(IfcEntityInstanceData(in_memory_attribute_storage(11))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_LongName) {set_attribute_value(7, (*v8_LongName)); }set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcElementCompositionEnum::Class(),(size_t)v9_CompositionType)));set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcInternalOrExternalEnum::Class(),(size_t)v10_InteriorOrExteriorSpace))); if (v11_ElevationWithFlooring) {set_attribute_value(10, (*v11_ElevationWithFlooring)); }; populate_derived(); }

// Function implementations for IfcSpaceHeaterType
::Ifc2x3::IfcSpaceHeaterTypeEnum::Value Ifc2x3::IfcSpaceHeaterType::PredefinedType() const {  return ::Ifc2x3::IfcSpaceHeaterTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcSpaceHeaterType::setPredefinedType(::Ifc2x3::IfcSpaceHeaterTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcSpaceHeaterTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcSpaceHeaterType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[780]); }
const IfcParse::entity& Ifc2x3::IfcSpaceHeaterType::Class() { return *((IfcParse::entity*)IFC2X3_types[780]); }
Ifc2x3::IfcSpaceHeaterType::IfcSpaceHeaterType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcSpaceHeaterType::IfcSpaceHeaterType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcSpaceHeaterTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcSpaceHeaterTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcSpaceProgram
std::string Ifc2x3::IfcSpaceProgram::SpaceProgramIdentifier() const {  std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcSpaceProgram::setSpaceProgramIdentifier(std::string v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
boost::optional< double > Ifc2x3::IfcSpaceProgram::MaxRequiredArea() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcSpaceProgram::setMaxRequiredArea(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
boost::optional< double > Ifc2x3::IfcSpaceProgram::MinRequiredArea() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcSpaceProgram::setMinRequiredArea(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
::Ifc2x3::IfcSpatialStructureElement* Ifc2x3::IfcSpaceProgram::RequestedLocation() const { if(get_attribute_value(8).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(8)))->as<::Ifc2x3::IfcSpatialStructureElement>(true); }
void Ifc2x3::IfcSpaceProgram::setRequestedLocation(::Ifc2x3::IfcSpatialStructureElement* v) { set_attribute_value(8, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(8); }
double Ifc2x3::IfcSpaceProgram::StandardRequiredArea() const {  double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcSpaceProgram::setStandardRequiredArea(double v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }

::Ifc2x3::IfcRelInteractionRequirements::list::ptr Ifc2x3::IfcSpaceProgram::HasInteractionReqsFrom() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[707], 7)->as<IfcRelInteractionRequirements>(); }
::Ifc2x3::IfcRelInteractionRequirements::list::ptr Ifc2x3::IfcSpaceProgram::HasInteractionReqsTo() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[707], 8)->as<IfcRelInteractionRequirements>(); }

const IfcParse::entity& Ifc2x3::IfcSpaceProgram::declaration() const { return *((IfcParse::entity*)IFC2X3_types[782]); }
const IfcParse::entity& Ifc2x3::IfcSpaceProgram::Class() { return *((IfcParse::entity*)IFC2X3_types[782]); }
Ifc2x3::IfcSpaceProgram::IfcSpaceProgram(IfcEntityInstanceData&& e) : IfcControl(std::move(e)) { }
Ifc2x3::IfcSpaceProgram::IfcSpaceProgram(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_SpaceProgramIdentifier, boost::optional< double > v7_MaxRequiredArea, boost::optional< double > v8_MinRequiredArea, ::Ifc2x3::IfcSpatialStructureElement* v9_RequestedLocation, double v10_StandardRequiredArea) : IfcControl(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (v6_SpaceProgramIdentifier)); if (v7_MaxRequiredArea) {set_attribute_value(6, (*v7_MaxRequiredArea)); } if (v8_MinRequiredArea) {set_attribute_value(7, (*v8_MinRequiredArea)); }set_attribute_value(8, v9_RequestedLocation ? v9_RequestedLocation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(9, (v10_StandardRequiredArea));; populate_derived(); }

// Function implementations for IfcSpaceThermalLoadProperties
boost::optional< double > Ifc2x3::IfcSpaceThermalLoadProperties::ApplicableValueRatio() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcSpaceThermalLoadProperties::setApplicableValueRatio(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
::Ifc2x3::IfcThermalLoadSourceEnum::Value Ifc2x3::IfcSpaceThermalLoadProperties::ThermalLoadSource() const {  return ::Ifc2x3::IfcThermalLoadSourceEnum::FromString(get_attribute_value(5)); }
void Ifc2x3::IfcSpaceThermalLoadProperties::setThermalLoadSource(::Ifc2x3::IfcThermalLoadSourceEnum::Value v) { set_attribute_value(5, EnumerationReference(&::Ifc2x3::IfcThermalLoadSourceEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcPropertySourceEnum::Value Ifc2x3::IfcSpaceThermalLoadProperties::PropertySource() const {  return ::Ifc2x3::IfcPropertySourceEnum::FromString(get_attribute_value(6)); }
void Ifc2x3::IfcSpaceThermalLoadProperties::setPropertySource(::Ifc2x3::IfcPropertySourceEnum::Value v) { set_attribute_value(6, EnumerationReference(&::Ifc2x3::IfcPropertySourceEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(6); }
boost::optional< std::string > Ifc2x3::IfcSpaceThermalLoadProperties::SourceDescription() const { if(get_attribute_value(7).isNull()) { return boost::none; } std::string v = get_attribute_value(7); return v; }
void Ifc2x3::IfcSpaceThermalLoadProperties::setSourceDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
double Ifc2x3::IfcSpaceThermalLoadProperties::MaximumValue() const {  double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcSpaceThermalLoadProperties::setMaximumValue(double v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
boost::optional< double > Ifc2x3::IfcSpaceThermalLoadProperties::MinimumValue() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcSpaceThermalLoadProperties::setMinimumValue(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
::Ifc2x3::IfcTimeSeries* Ifc2x3::IfcSpaceThermalLoadProperties::ThermalLoadTimeSeriesValues() const { if(get_attribute_value(10).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(10)))->as<::Ifc2x3::IfcTimeSeries>(true); }
void Ifc2x3::IfcSpaceThermalLoadProperties::setThermalLoadTimeSeriesValues(::Ifc2x3::IfcTimeSeries* v) { set_attribute_value(10, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(10); }
boost::optional< std::string > Ifc2x3::IfcSpaceThermalLoadProperties::UserDefinedThermalLoadSource() const { if(get_attribute_value(11).isNull()) { return boost::none; } std::string v = get_attribute_value(11); return v; }
void Ifc2x3::IfcSpaceThermalLoadProperties::setUserDefinedThermalLoadSource(boost::optional< std::string > v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
boost::optional< std::string > Ifc2x3::IfcSpaceThermalLoadProperties::UserDefinedPropertySource() const { if(get_attribute_value(12).isNull()) { return boost::none; } std::string v = get_attribute_value(12); return v; }
void Ifc2x3::IfcSpaceThermalLoadProperties::setUserDefinedPropertySource(boost::optional< std::string > v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
::Ifc2x3::IfcThermalLoadTypeEnum::Value Ifc2x3::IfcSpaceThermalLoadProperties::ThermalLoadType() const {  return ::Ifc2x3::IfcThermalLoadTypeEnum::FromString(get_attribute_value(13)); }
void Ifc2x3::IfcSpaceThermalLoadProperties::setThermalLoadType(::Ifc2x3::IfcThermalLoadTypeEnum::Value v) { set_attribute_value(13, EnumerationReference(&::Ifc2x3::IfcThermalLoadTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(13); }


const IfcParse::entity& Ifc2x3::IfcSpaceThermalLoadProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[783]); }
const IfcParse::entity& Ifc2x3::IfcSpaceThermalLoadProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[783]); }
Ifc2x3::IfcSpaceThermalLoadProperties::IfcSpaceThermalLoadProperties(IfcEntityInstanceData&& e) : IfcPropertySetDefinition(std::move(e)) { }
Ifc2x3::IfcSpaceThermalLoadProperties::IfcSpaceThermalLoadProperties(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_ApplicableValueRatio, ::Ifc2x3::IfcThermalLoadSourceEnum::Value v6_ThermalLoadSource, ::Ifc2x3::IfcPropertySourceEnum::Value v7_PropertySource, boost::optional< std::string > v8_SourceDescription, double v9_MaximumValue, boost::optional< double > v10_MinimumValue, ::Ifc2x3::IfcTimeSeries* v11_ThermalLoadTimeSeriesValues, boost::optional< std::string > v12_UserDefinedThermalLoadSource, boost::optional< std::string > v13_UserDefinedPropertySource, ::Ifc2x3::IfcThermalLoadTypeEnum::Value v14_ThermalLoadType) : IfcPropertySetDefinition(IfcEntityInstanceData(in_memory_attribute_storage(14))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableValueRatio) {set_attribute_value(4, (*v5_ApplicableValueRatio)); }set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcThermalLoadSourceEnum::Class(),(size_t)v6_ThermalLoadSource)));set_attribute_value(6, (EnumerationReference(&::Ifc2x3::IfcPropertySourceEnum::Class(),(size_t)v7_PropertySource))); if (v8_SourceDescription) {set_attribute_value(7, (*v8_SourceDescription)); }set_attribute_value(8, (v9_MaximumValue)); if (v10_MinimumValue) {set_attribute_value(9, (*v10_MinimumValue)); }set_attribute_value(10, v11_ThermalLoadTimeSeriesValues ? v11_ThermalLoadTimeSeriesValues->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v12_UserDefinedThermalLoadSource) {set_attribute_value(11, (*v12_UserDefinedThermalLoadSource)); } if (v13_UserDefinedPropertySource) {set_attribute_value(12, (*v13_UserDefinedPropertySource)); }set_attribute_value(13, (EnumerationReference(&::Ifc2x3::IfcThermalLoadTypeEnum::Class(),(size_t)v14_ThermalLoadType)));; populate_derived(); }

// Function implementations for IfcSpaceType
::Ifc2x3::IfcSpaceTypeEnum::Value Ifc2x3::IfcSpaceType::PredefinedType() const {  return ::Ifc2x3::IfcSpaceTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcSpaceType::setPredefinedType(::Ifc2x3::IfcSpaceTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcSpaceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcSpaceType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[784]); }
const IfcParse::entity& Ifc2x3::IfcSpaceType::Class() { return *((IfcParse::entity*)IFC2X3_types[784]); }
Ifc2x3::IfcSpaceType::IfcSpaceType(IfcEntityInstanceData&& e) : IfcSpatialStructureElementType(std::move(e)) { }
Ifc2x3::IfcSpaceType::IfcSpaceType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcSpaceTypeEnum::Value v10_PredefinedType) : IfcSpatialStructureElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcSpaceTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcSpatialStructureElement
boost::optional< std::string > Ifc2x3::IfcSpatialStructureElement::LongName() const { if(get_attribute_value(7).isNull()) { return boost::none; } std::string v = get_attribute_value(7); return v; }
void Ifc2x3::IfcSpatialStructureElement::setLongName(boost::optional< std::string > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
::Ifc2x3::IfcElementCompositionEnum::Value Ifc2x3::IfcSpatialStructureElement::CompositionType() const {  return ::Ifc2x3::IfcElementCompositionEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcSpatialStructureElement::setCompositionType(::Ifc2x3::IfcElementCompositionEnum::Value v) { set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcElementCompositionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }

::Ifc2x3::IfcRelReferencedInSpatialStructure::list::ptr Ifc2x3::IfcSpatialStructureElement::ReferencesElements() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[712], 5)->as<IfcRelReferencedInSpatialStructure>(); }
::Ifc2x3::IfcRelServicesBuildings::list::ptr Ifc2x3::IfcSpatialStructureElement::ServicedBySystems() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[715], 5)->as<IfcRelServicesBuildings>(); }
::Ifc2x3::IfcRelContainedInSpatialStructure::list::ptr Ifc2x3::IfcSpatialStructureElement::ContainsElements() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[698], 5)->as<IfcRelContainedInSpatialStructure>(); }

const IfcParse::entity& Ifc2x3::IfcSpatialStructureElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[786]); }
const IfcParse::entity& Ifc2x3::IfcSpatialStructureElement::Class() { return *((IfcParse::entity*)IFC2X3_types[786]); }
Ifc2x3::IfcSpatialStructureElement::IfcSpatialStructureElement(IfcEntityInstanceData&& e) : IfcProduct(std::move(e)) { }
Ifc2x3::IfcSpatialStructureElement::IfcSpatialStructureElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_LongName, ::Ifc2x3::IfcElementCompositionEnum::Value v9_CompositionType) : IfcProduct(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_LongName) {set_attribute_value(7, (*v8_LongName)); }set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcElementCompositionEnum::Class(),(size_t)v9_CompositionType)));; populate_derived(); }

// Function implementations for IfcSpatialStructureElementType


const IfcParse::entity& Ifc2x3::IfcSpatialStructureElementType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[787]); }
const IfcParse::entity& Ifc2x3::IfcSpatialStructureElementType::Class() { return *((IfcParse::entity*)IFC2X3_types[787]); }
Ifc2x3::IfcSpatialStructureElementType::IfcSpatialStructureElementType(IfcEntityInstanceData&& e) : IfcElementType(std::move(e)) { }
Ifc2x3::IfcSpatialStructureElementType::IfcSpatialStructureElementType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcElementType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcSphere
double Ifc2x3::IfcSphere::Radius() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcSphere::setRadius(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcSphere::declaration() const { return *((IfcParse::entity*)IFC2X3_types[792]); }
const IfcParse::entity& Ifc2x3::IfcSphere::Class() { return *((IfcParse::entity*)IFC2X3_types[792]); }
Ifc2x3::IfcSphere::IfcSphere(IfcEntityInstanceData&& e) : IfcCsgPrimitive3D(std::move(e)) { }
Ifc2x3::IfcSphere::IfcSphere(::Ifc2x3::IfcAxis2Placement3D* v1_Position, double v2_Radius) : IfcCsgPrimitive3D(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_Position ? v1_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Radius));; populate_derived(); }

// Function implementations for IfcStackTerminalType
::Ifc2x3::IfcStackTerminalTypeEnum::Value Ifc2x3::IfcStackTerminalType::PredefinedType() const {  return ::Ifc2x3::IfcStackTerminalTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcStackTerminalType::setPredefinedType(::Ifc2x3::IfcStackTerminalTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcStackTerminalTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcStackTerminalType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[793]); }
const IfcParse::entity& Ifc2x3::IfcStackTerminalType::Class() { return *((IfcParse::entity*)IFC2X3_types[793]); }
Ifc2x3::IfcStackTerminalType::IfcStackTerminalType(IfcEntityInstanceData&& e) : IfcFlowTerminalType(std::move(e)) { }
Ifc2x3::IfcStackTerminalType::IfcStackTerminalType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcStackTerminalTypeEnum::Value v10_PredefinedType) : IfcFlowTerminalType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcStackTerminalTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcStair
::Ifc2x3::IfcStairTypeEnum::Value Ifc2x3::IfcStair::ShapeType() const {  return ::Ifc2x3::IfcStairTypeEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcStair::setShapeType(::Ifc2x3::IfcStairTypeEnum::Value v) { set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcStairTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }


const IfcParse::entity& Ifc2x3::IfcStair::declaration() const { return *((IfcParse::entity*)IFC2X3_types[795]); }
const IfcParse::entity& Ifc2x3::IfcStair::Class() { return *((IfcParse::entity*)IFC2X3_types[795]); }
Ifc2x3::IfcStair::IfcStair(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcStair::IfcStair(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, ::Ifc2x3::IfcStairTypeEnum::Value v9_ShapeType) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcStairTypeEnum::Class(),(size_t)v9_ShapeType)));; populate_derived(); }

// Function implementations for IfcStairFlight
boost::optional< int > Ifc2x3::IfcStairFlight::NumberOfRiser() const { if(get_attribute_value(8).isNull()) { return boost::none; } int v = get_attribute_value(8); return v; }
void Ifc2x3::IfcStairFlight::setNumberOfRiser(boost::optional< int > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
boost::optional< int > Ifc2x3::IfcStairFlight::NumberOfTreads() const { if(get_attribute_value(9).isNull()) { return boost::none; } int v = get_attribute_value(9); return v; }
void Ifc2x3::IfcStairFlight::setNumberOfTreads(boost::optional< int > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
boost::optional< double > Ifc2x3::IfcStairFlight::RiserHeight() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcStairFlight::setRiserHeight(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
boost::optional< double > Ifc2x3::IfcStairFlight::TreadLength() const { if(get_attribute_value(11).isNull()) { return boost::none; } double v = get_attribute_value(11); return v; }
void Ifc2x3::IfcStairFlight::setTreadLength(boost::optional< double > v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }


const IfcParse::entity& Ifc2x3::IfcStairFlight::declaration() const { return *((IfcParse::entity*)IFC2X3_types[796]); }
const IfcParse::entity& Ifc2x3::IfcStairFlight::Class() { return *((IfcParse::entity*)IFC2X3_types[796]); }
Ifc2x3::IfcStairFlight::IfcStairFlight(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcStairFlight::IfcStairFlight(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< int > v9_NumberOfRiser, boost::optional< int > v10_NumberOfTreads, boost::optional< double > v11_RiserHeight, boost::optional< double > v12_TreadLength) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(12))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_NumberOfRiser) {set_attribute_value(8, (*v9_NumberOfRiser)); } if (v10_NumberOfTreads) {set_attribute_value(9, (*v10_NumberOfTreads)); } if (v11_RiserHeight) {set_attribute_value(10, (*v11_RiserHeight)); } if (v12_TreadLength) {set_attribute_value(11, (*v12_TreadLength)); }; populate_derived(); }

// Function implementations for IfcStairFlightType
::Ifc2x3::IfcStairFlightTypeEnum::Value Ifc2x3::IfcStairFlightType::PredefinedType() const {  return ::Ifc2x3::IfcStairFlightTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcStairFlightType::setPredefinedType(::Ifc2x3::IfcStairFlightTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcStairFlightTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcStairFlightType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[797]); }
const IfcParse::entity& Ifc2x3::IfcStairFlightType::Class() { return *((IfcParse::entity*)IFC2X3_types[797]); }
Ifc2x3::IfcStairFlightType::IfcStairFlightType(IfcEntityInstanceData&& e) : IfcBuildingElementType(std::move(e)) { }
Ifc2x3::IfcStairFlightType::IfcStairFlightType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcStairFlightTypeEnum::Value v10_PredefinedType) : IfcBuildingElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcStairFlightTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcStructuralAction
bool Ifc2x3::IfcStructuralAction::DestabilizingLoad() const {  bool v = get_attribute_value(9); return v; }
void Ifc2x3::IfcStructuralAction::setDestabilizingLoad(bool v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }
::Ifc2x3::IfcStructuralReaction* Ifc2x3::IfcStructuralAction::CausedBy() const { if(get_attribute_value(10).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(10)))->as<::Ifc2x3::IfcStructuralReaction>(true); }
void Ifc2x3::IfcStructuralAction::setCausedBy(::Ifc2x3::IfcStructuralReaction* v) { set_attribute_value(10, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(10); }


const IfcParse::entity& Ifc2x3::IfcStructuralAction::declaration() const { return *((IfcParse::entity*)IFC2X3_types[801]); }
const IfcParse::entity& Ifc2x3::IfcStructuralAction::Class() { return *((IfcParse::entity*)IFC2X3_types[801]); }
Ifc2x3::IfcStructuralAction::IfcStructuralAction(IfcEntityInstanceData&& e) : IfcStructuralActivity(std::move(e)) { }
Ifc2x3::IfcStructuralAction::IfcStructuralAction(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcStructuralLoad* v8_AppliedLoad, ::Ifc2x3::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal, bool v10_DestabilizingLoad, ::Ifc2x3::IfcStructuralReaction* v11_CausedBy) : IfcStructuralActivity(IfcEntityInstanceData(in_memory_attribute_storage(11))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_AppliedLoad ? v8_AppliedLoad->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal)));set_attribute_value(9, (v10_DestabilizingLoad));set_attribute_value(10, v11_CausedBy ? v11_CausedBy->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcStructuralActivity
::Ifc2x3::IfcStructuralLoad* Ifc2x3::IfcStructuralActivity::AppliedLoad() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(7)))->as<::Ifc2x3::IfcStructuralLoad>(true); }
void Ifc2x3::IfcStructuralActivity::setAppliedLoad(::Ifc2x3::IfcStructuralLoad* v) { set_attribute_value(7, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(7); }
::Ifc2x3::IfcGlobalOrLocalEnum::Value Ifc2x3::IfcStructuralActivity::GlobalOrLocal() const {  return ::Ifc2x3::IfcGlobalOrLocalEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcStructuralActivity::setGlobalOrLocal(::Ifc2x3::IfcGlobalOrLocalEnum::Value v) { set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcGlobalOrLocalEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }

::Ifc2x3::IfcRelConnectsStructuralActivity::list::ptr Ifc2x3::IfcStructuralActivity::AssignedToStructuralItem() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[693], 5)->as<IfcRelConnectsStructuralActivity>(); }

const IfcParse::entity& Ifc2x3::IfcStructuralActivity::declaration() const { return *((IfcParse::entity*)IFC2X3_types[802]); }
const IfcParse::entity& Ifc2x3::IfcStructuralActivity::Class() { return *((IfcParse::entity*)IFC2X3_types[802]); }
Ifc2x3::IfcStructuralActivity::IfcStructuralActivity(IfcEntityInstanceData&& e) : IfcProduct(std::move(e)) { }
Ifc2x3::IfcStructuralActivity::IfcStructuralActivity(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcStructuralLoad* v8_AppliedLoad, ::Ifc2x3::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal) : IfcProduct(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_AppliedLoad ? v8_AppliedLoad->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal)));; populate_derived(); }

// Function implementations for IfcStructuralAnalysisModel
::Ifc2x3::IfcAnalysisModelTypeEnum::Value Ifc2x3::IfcStructuralAnalysisModel::PredefinedType() const {  return ::Ifc2x3::IfcAnalysisModelTypeEnum::FromString(get_attribute_value(5)); }
void Ifc2x3::IfcStructuralAnalysisModel::setPredefinedType(::Ifc2x3::IfcAnalysisModelTypeEnum::Value v) { set_attribute_value(5, EnumerationReference(&::Ifc2x3::IfcAnalysisModelTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcAxis2Placement3D* Ifc2x3::IfcStructuralAnalysisModel::OrientationOf2DPlane() const { if(get_attribute_value(6).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcAxis2Placement3D>(true); }
void Ifc2x3::IfcStructuralAnalysisModel::setOrientationOf2DPlane(::Ifc2x3::IfcAxis2Placement3D* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
boost::optional< aggregate_of< ::Ifc2x3::IfcStructuralLoadGroup >::ptr > Ifc2x3::IfcStructuralAnalysisModel::LoadedBy() const { if(get_attribute_value(7).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(7); return es->as< ::Ifc2x3::IfcStructuralLoadGroup >(); }
void Ifc2x3::IfcStructuralAnalysisModel::setLoadedBy(boost::optional< aggregate_of< ::Ifc2x3::IfcStructuralLoadGroup >::ptr > v) { if (v) {set_attribute_value(7, (*v)->generalize());} else {unset_attribute_value(7);} }
boost::optional< aggregate_of< ::Ifc2x3::IfcStructuralResultGroup >::ptr > Ifc2x3::IfcStructuralAnalysisModel::HasResults() const { if(get_attribute_value(8).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(8); return es->as< ::Ifc2x3::IfcStructuralResultGroup >(); }
void Ifc2x3::IfcStructuralAnalysisModel::setHasResults(boost::optional< aggregate_of< ::Ifc2x3::IfcStructuralResultGroup >::ptr > v) { if (v) {set_attribute_value(8, (*v)->generalize());} else {unset_attribute_value(8);} }


const IfcParse::entity& Ifc2x3::IfcStructuralAnalysisModel::declaration() const { return *((IfcParse::entity*)IFC2X3_types[804]); }
const IfcParse::entity& Ifc2x3::IfcStructuralAnalysisModel::Class() { return *((IfcParse::entity*)IFC2X3_types[804]); }
Ifc2x3::IfcStructuralAnalysisModel::IfcStructuralAnalysisModel(IfcEntityInstanceData&& e) : IfcSystem(std::move(e)) { }
Ifc2x3::IfcStructuralAnalysisModel::IfcStructuralAnalysisModel(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcAnalysisModelTypeEnum::Value v6_PredefinedType, ::Ifc2x3::IfcAxis2Placement3D* v7_OrientationOf2DPlane, boost::optional< aggregate_of< ::Ifc2x3::IfcStructuralLoadGroup >::ptr > v8_LoadedBy, boost::optional< aggregate_of< ::Ifc2x3::IfcStructuralResultGroup >::ptr > v9_HasResults) : IfcSystem(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcAnalysisModelTypeEnum::Class(),(size_t)v6_PredefinedType)));set_attribute_value(6, v7_OrientationOf2DPlane ? v7_OrientationOf2DPlane->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_LoadedBy) {set_attribute_value(7, (*v8_LoadedBy)->generalize()); } if (v9_HasResults) {set_attribute_value(8, (*v9_HasResults)->generalize()); }; populate_derived(); }

// Function implementations for IfcStructuralConnection
::Ifc2x3::IfcBoundaryCondition* Ifc2x3::IfcStructuralConnection::AppliedCondition() const { if(get_attribute_value(7).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(7)))->as<::Ifc2x3::IfcBoundaryCondition>(true); }
void Ifc2x3::IfcStructuralConnection::setAppliedCondition(::Ifc2x3::IfcBoundaryCondition* v) { set_attribute_value(7, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(7); }

::Ifc2x3::IfcRelConnectsStructuralMember::list::ptr Ifc2x3::IfcStructuralConnection::ConnectsStructuralMembers() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[695], 5)->as<IfcRelConnectsStructuralMember>(); }

const IfcParse::entity& Ifc2x3::IfcStructuralConnection::declaration() const { return *((IfcParse::entity*)IFC2X3_types[805]); }
const IfcParse::entity& Ifc2x3::IfcStructuralConnection::Class() { return *((IfcParse::entity*)IFC2X3_types[805]); }
Ifc2x3::IfcStructuralConnection::IfcStructuralConnection(IfcEntityInstanceData&& e) : IfcStructuralItem(std::move(e)) { }
Ifc2x3::IfcStructuralConnection::IfcStructuralConnection(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcBoundaryCondition* v8_AppliedCondition) : IfcStructuralItem(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_AppliedCondition ? v8_AppliedCondition->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcStructuralConnectionCondition
boost::optional< std::string > Ifc2x3::IfcStructuralConnectionCondition::Name() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcStructuralConnectionCondition::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }


const IfcParse::entity& Ifc2x3::IfcStructuralConnectionCondition::declaration() const { return *((IfcParse::entity*)IFC2X3_types[806]); }
const IfcParse::entity& Ifc2x3::IfcStructuralConnectionCondition::Class() { return *((IfcParse::entity*)IFC2X3_types[806]); }
Ifc2x3::IfcStructuralConnectionCondition::IfcStructuralConnectionCondition(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcStructuralConnectionCondition::IfcStructuralConnectionCondition(boost::optional< std::string > v1_Name) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }; populate_derived(); }

// Function implementations for IfcStructuralCurveConnection


const IfcParse::entity& Ifc2x3::IfcStructuralCurveConnection::declaration() const { return *((IfcParse::entity*)IFC2X3_types[807]); }
const IfcParse::entity& Ifc2x3::IfcStructuralCurveConnection::Class() { return *((IfcParse::entity*)IFC2X3_types[807]); }
Ifc2x3::IfcStructuralCurveConnection::IfcStructuralCurveConnection(IfcEntityInstanceData&& e) : IfcStructuralConnection(std::move(e)) { }
Ifc2x3::IfcStructuralCurveConnection::IfcStructuralCurveConnection(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcBoundaryCondition* v8_AppliedCondition) : IfcStructuralConnection(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_AppliedCondition ? v8_AppliedCondition->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcStructuralCurveMember
::Ifc2x3::IfcStructuralCurveTypeEnum::Value Ifc2x3::IfcStructuralCurveMember::PredefinedType() const {  return ::Ifc2x3::IfcStructuralCurveTypeEnum::FromString(get_attribute_value(7)); }
void Ifc2x3::IfcStructuralCurveMember::setPredefinedType(::Ifc2x3::IfcStructuralCurveTypeEnum::Value v) { set_attribute_value(7, EnumerationReference(&::Ifc2x3::IfcStructuralCurveTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }


const IfcParse::entity& Ifc2x3::IfcStructuralCurveMember::declaration() const { return *((IfcParse::entity*)IFC2X3_types[808]); }
const IfcParse::entity& Ifc2x3::IfcStructuralCurveMember::Class() { return *((IfcParse::entity*)IFC2X3_types[808]); }
Ifc2x3::IfcStructuralCurveMember::IfcStructuralCurveMember(IfcEntityInstanceData&& e) : IfcStructuralMember(std::move(e)) { }
Ifc2x3::IfcStructuralCurveMember::IfcStructuralCurveMember(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcStructuralCurveTypeEnum::Value v8_PredefinedType) : IfcStructuralMember(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcStructuralCurveTypeEnum::Class(),(size_t)v8_PredefinedType)));; populate_derived(); }

// Function implementations for IfcStructuralCurveMemberVarying


const IfcParse::entity& Ifc2x3::IfcStructuralCurveMemberVarying::declaration() const { return *((IfcParse::entity*)IFC2X3_types[809]); }
const IfcParse::entity& Ifc2x3::IfcStructuralCurveMemberVarying::Class() { return *((IfcParse::entity*)IFC2X3_types[809]); }
Ifc2x3::IfcStructuralCurveMemberVarying::IfcStructuralCurveMemberVarying(IfcEntityInstanceData&& e) : IfcStructuralCurveMember(std::move(e)) { }
Ifc2x3::IfcStructuralCurveMemberVarying::IfcStructuralCurveMemberVarying(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcStructuralCurveTypeEnum::Value v8_PredefinedType) : IfcStructuralCurveMember(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcStructuralCurveTypeEnum::Class(),(size_t)v8_PredefinedType)));; populate_derived(); }

// Function implementations for IfcStructuralItem

::Ifc2x3::IfcRelConnectsStructuralActivity::list::ptr Ifc2x3::IfcStructuralItem::AssignedStructuralActivity() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[693], 4)->as<IfcRelConnectsStructuralActivity>(); }

const IfcParse::entity& Ifc2x3::IfcStructuralItem::declaration() const { return *((IfcParse::entity*)IFC2X3_types[811]); }
const IfcParse::entity& Ifc2x3::IfcStructuralItem::Class() { return *((IfcParse::entity*)IFC2X3_types[811]); }
Ifc2x3::IfcStructuralItem::IfcStructuralItem(IfcEntityInstanceData&& e) : IfcProduct(std::move(e)) { }
Ifc2x3::IfcStructuralItem::IfcStructuralItem(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation) : IfcProduct(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcStructuralLinearAction
::Ifc2x3::IfcProjectedOrTrueLengthEnum::Value Ifc2x3::IfcStructuralLinearAction::ProjectedOrTrue() const {  return ::Ifc2x3::IfcProjectedOrTrueLengthEnum::FromString(get_attribute_value(11)); }
void Ifc2x3::IfcStructuralLinearAction::setProjectedOrTrue(::Ifc2x3::IfcProjectedOrTrueLengthEnum::Value v) { set_attribute_value(11, EnumerationReference(&::Ifc2x3::IfcProjectedOrTrueLengthEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(11); }


const IfcParse::entity& Ifc2x3::IfcStructuralLinearAction::declaration() const { return *((IfcParse::entity*)IFC2X3_types[812]); }
const IfcParse::entity& Ifc2x3::IfcStructuralLinearAction::Class() { return *((IfcParse::entity*)IFC2X3_types[812]); }
Ifc2x3::IfcStructuralLinearAction::IfcStructuralLinearAction(IfcEntityInstanceData&& e) : IfcStructuralAction(std::move(e)) { }
Ifc2x3::IfcStructuralLinearAction::IfcStructuralLinearAction(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcStructuralLoad* v8_AppliedLoad, ::Ifc2x3::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal, bool v10_DestabilizingLoad, ::Ifc2x3::IfcStructuralReaction* v11_CausedBy, ::Ifc2x3::IfcProjectedOrTrueLengthEnum::Value v12_ProjectedOrTrue) : IfcStructuralAction(IfcEntityInstanceData(in_memory_attribute_storage(12))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_AppliedLoad ? v8_AppliedLoad->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal)));set_attribute_value(9, (v10_DestabilizingLoad));set_attribute_value(10, v11_CausedBy ? v11_CausedBy->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(11, (EnumerationReference(&::Ifc2x3::IfcProjectedOrTrueLengthEnum::Class(),(size_t)v12_ProjectedOrTrue)));; populate_derived(); }

// Function implementations for IfcStructuralLinearActionVarying
::Ifc2x3::IfcShapeAspect* Ifc2x3::IfcStructuralLinearActionVarying::VaryingAppliedLoadLocation() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(12)))->as<::Ifc2x3::IfcShapeAspect>(true); }
void Ifc2x3::IfcStructuralLinearActionVarying::setVaryingAppliedLoadLocation(::Ifc2x3::IfcShapeAspect* v) { set_attribute_value(12, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(12); }
aggregate_of< ::Ifc2x3::IfcStructuralLoad >::ptr Ifc2x3::IfcStructuralLinearActionVarying::SubsequentAppliedLoads() const {  aggregate_of_instance::ptr es = get_attribute_value(13); return es->as< ::Ifc2x3::IfcStructuralLoad >(); }
void Ifc2x3::IfcStructuralLinearActionVarying::setSubsequentAppliedLoads(aggregate_of< ::Ifc2x3::IfcStructuralLoad >::ptr v) { set_attribute_value(13, (v)->generalize());if constexpr (false)unset_attribute_value(13); }


const IfcParse::entity& Ifc2x3::IfcStructuralLinearActionVarying::declaration() const { return *((IfcParse::entity*)IFC2X3_types[813]); }
const IfcParse::entity& Ifc2x3::IfcStructuralLinearActionVarying::Class() { return *((IfcParse::entity*)IFC2X3_types[813]); }
Ifc2x3::IfcStructuralLinearActionVarying::IfcStructuralLinearActionVarying(IfcEntityInstanceData&& e) : IfcStructuralLinearAction(std::move(e)) { }
Ifc2x3::IfcStructuralLinearActionVarying::IfcStructuralLinearActionVarying(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcStructuralLoad* v8_AppliedLoad, ::Ifc2x3::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal, bool v10_DestabilizingLoad, ::Ifc2x3::IfcStructuralReaction* v11_CausedBy, ::Ifc2x3::IfcProjectedOrTrueLengthEnum::Value v12_ProjectedOrTrue, ::Ifc2x3::IfcShapeAspect* v13_VaryingAppliedLoadLocation, aggregate_of< ::Ifc2x3::IfcStructuralLoad >::ptr v14_SubsequentAppliedLoads) : IfcStructuralLinearAction(IfcEntityInstanceData(in_memory_attribute_storage(14))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_AppliedLoad ? v8_AppliedLoad->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal)));set_attribute_value(9, (v10_DestabilizingLoad));set_attribute_value(10, v11_CausedBy ? v11_CausedBy->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(11, (EnumerationReference(&::Ifc2x3::IfcProjectedOrTrueLengthEnum::Class(),(size_t)v12_ProjectedOrTrue)));set_attribute_value(12, v13_VaryingAppliedLoadLocation ? v13_VaryingAppliedLoadLocation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(13, (v14_SubsequentAppliedLoads)->generalize());; populate_derived(); }

// Function implementations for IfcStructuralLoad
boost::optional< std::string > Ifc2x3::IfcStructuralLoad::Name() const { if(get_attribute_value(0).isNull()) { return boost::none; } std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcStructuralLoad::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }


const IfcParse::entity& Ifc2x3::IfcStructuralLoad::declaration() const { return *((IfcParse::entity*)IFC2X3_types[814]); }
const IfcParse::entity& Ifc2x3::IfcStructuralLoad::Class() { return *((IfcParse::entity*)IFC2X3_types[814]); }
Ifc2x3::IfcStructuralLoad::IfcStructuralLoad(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcStructuralLoad::IfcStructuralLoad(boost::optional< std::string > v1_Name) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }; populate_derived(); }

// Function implementations for IfcStructuralLoadGroup
::Ifc2x3::IfcLoadGroupTypeEnum::Value Ifc2x3::IfcStructuralLoadGroup::PredefinedType() const {  return ::Ifc2x3::IfcLoadGroupTypeEnum::FromString(get_attribute_value(5)); }
void Ifc2x3::IfcStructuralLoadGroup::setPredefinedType(::Ifc2x3::IfcLoadGroupTypeEnum::Value v) { set_attribute_value(5, EnumerationReference(&::Ifc2x3::IfcLoadGroupTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcActionTypeEnum::Value Ifc2x3::IfcStructuralLoadGroup::ActionType() const {  return ::Ifc2x3::IfcActionTypeEnum::FromString(get_attribute_value(6)); }
void Ifc2x3::IfcStructuralLoadGroup::setActionType(::Ifc2x3::IfcActionTypeEnum::Value v) { set_attribute_value(6, EnumerationReference(&::Ifc2x3::IfcActionTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(6); }
::Ifc2x3::IfcActionSourceTypeEnum::Value Ifc2x3::IfcStructuralLoadGroup::ActionSource() const {  return ::Ifc2x3::IfcActionSourceTypeEnum::FromString(get_attribute_value(7)); }
void Ifc2x3::IfcStructuralLoadGroup::setActionSource(::Ifc2x3::IfcActionSourceTypeEnum::Value v) { set_attribute_value(7, EnumerationReference(&::Ifc2x3::IfcActionSourceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }
boost::optional< double > Ifc2x3::IfcStructuralLoadGroup::Coefficient() const { if(get_attribute_value(8).isNull()) { return boost::none; } double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcStructuralLoadGroup::setCoefficient(boost::optional< double > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
boost::optional< std::string > Ifc2x3::IfcStructuralLoadGroup::Purpose() const { if(get_attribute_value(9).isNull()) { return boost::none; } std::string v = get_attribute_value(9); return v; }
void Ifc2x3::IfcStructuralLoadGroup::setPurpose(boost::optional< std::string > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }

::Ifc2x3::IfcStructuralResultGroup::list::ptr Ifc2x3::IfcStructuralLoadGroup::SourceOfResultGroup() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[832], 6)->as<IfcStructuralResultGroup>(); }
::Ifc2x3::IfcStructuralAnalysisModel::list::ptr Ifc2x3::IfcStructuralLoadGroup::LoadGroupFor() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[804], 7)->as<IfcStructuralAnalysisModel>(); }

const IfcParse::entity& Ifc2x3::IfcStructuralLoadGroup::declaration() const { return *((IfcParse::entity*)IFC2X3_types[815]); }
const IfcParse::entity& Ifc2x3::IfcStructuralLoadGroup::Class() { return *((IfcParse::entity*)IFC2X3_types[815]); }
Ifc2x3::IfcStructuralLoadGroup::IfcStructuralLoadGroup(IfcEntityInstanceData&& e) : IfcGroup(std::move(e)) { }
Ifc2x3::IfcStructuralLoadGroup::IfcStructuralLoadGroup(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcLoadGroupTypeEnum::Value v6_PredefinedType, ::Ifc2x3::IfcActionTypeEnum::Value v7_ActionType, ::Ifc2x3::IfcActionSourceTypeEnum::Value v8_ActionSource, boost::optional< double > v9_Coefficient, boost::optional< std::string > v10_Purpose) : IfcGroup(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcLoadGroupTypeEnum::Class(),(size_t)v6_PredefinedType)));set_attribute_value(6, (EnumerationReference(&::Ifc2x3::IfcActionTypeEnum::Class(),(size_t)v7_ActionType)));set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcActionSourceTypeEnum::Class(),(size_t)v8_ActionSource))); if (v9_Coefficient) {set_attribute_value(8, (*v9_Coefficient)); } if (v10_Purpose) {set_attribute_value(9, (*v10_Purpose)); }; populate_derived(); }

// Function implementations for IfcStructuralLoadLinearForce
boost::optional< double > Ifc2x3::IfcStructuralLoadLinearForce::LinearForceX() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcStructuralLoadLinearForce::setLinearForceX(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadLinearForce::LinearForceY() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcStructuralLoadLinearForce::setLinearForceY(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadLinearForce::LinearForceZ() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcStructuralLoadLinearForce::setLinearForceZ(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadLinearForce::LinearMomentX() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcStructuralLoadLinearForce::setLinearMomentX(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadLinearForce::LinearMomentY() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcStructuralLoadLinearForce::setLinearMomentY(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadLinearForce::LinearMomentZ() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcStructuralLoadLinearForce::setLinearMomentZ(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }


const IfcParse::entity& Ifc2x3::IfcStructuralLoadLinearForce::declaration() const { return *((IfcParse::entity*)IFC2X3_types[816]); }
const IfcParse::entity& Ifc2x3::IfcStructuralLoadLinearForce::Class() { return *((IfcParse::entity*)IFC2X3_types[816]); }
Ifc2x3::IfcStructuralLoadLinearForce::IfcStructuralLoadLinearForce(IfcEntityInstanceData&& e) : IfcStructuralLoadStatic(std::move(e)) { }
Ifc2x3::IfcStructuralLoadLinearForce::IfcStructuralLoadLinearForce(boost::optional< std::string > v1_Name, boost::optional< double > v2_LinearForceX, boost::optional< double > v3_LinearForceY, boost::optional< double > v4_LinearForceZ, boost::optional< double > v5_LinearMomentX, boost::optional< double > v6_LinearMomentY, boost::optional< double > v7_LinearMomentZ) : IfcStructuralLoadStatic(IfcEntityInstanceData(in_memory_attribute_storage(7))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_LinearForceX) {set_attribute_value(1, (*v2_LinearForceX)); } if (v3_LinearForceY) {set_attribute_value(2, (*v3_LinearForceY)); } if (v4_LinearForceZ) {set_attribute_value(3, (*v4_LinearForceZ)); } if (v5_LinearMomentX) {set_attribute_value(4, (*v5_LinearMomentX)); } if (v6_LinearMomentY) {set_attribute_value(5, (*v6_LinearMomentY)); } if (v7_LinearMomentZ) {set_attribute_value(6, (*v7_LinearMomentZ)); }; populate_derived(); }

// Function implementations for IfcStructuralLoadPlanarForce
boost::optional< double > Ifc2x3::IfcStructuralLoadPlanarForce::PlanarForceX() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcStructuralLoadPlanarForce::setPlanarForceX(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadPlanarForce::PlanarForceY() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcStructuralLoadPlanarForce::setPlanarForceY(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadPlanarForce::PlanarForceZ() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcStructuralLoadPlanarForce::setPlanarForceZ(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }


const IfcParse::entity& Ifc2x3::IfcStructuralLoadPlanarForce::declaration() const { return *((IfcParse::entity*)IFC2X3_types[817]); }
const IfcParse::entity& Ifc2x3::IfcStructuralLoadPlanarForce::Class() { return *((IfcParse::entity*)IFC2X3_types[817]); }
Ifc2x3::IfcStructuralLoadPlanarForce::IfcStructuralLoadPlanarForce(IfcEntityInstanceData&& e) : IfcStructuralLoadStatic(std::move(e)) { }
Ifc2x3::IfcStructuralLoadPlanarForce::IfcStructuralLoadPlanarForce(boost::optional< std::string > v1_Name, boost::optional< double > v2_PlanarForceX, boost::optional< double > v3_PlanarForceY, boost::optional< double > v4_PlanarForceZ) : IfcStructuralLoadStatic(IfcEntityInstanceData(in_memory_attribute_storage(4))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_PlanarForceX) {set_attribute_value(1, (*v2_PlanarForceX)); } if (v3_PlanarForceY) {set_attribute_value(2, (*v3_PlanarForceY)); } if (v4_PlanarForceZ) {set_attribute_value(3, (*v4_PlanarForceZ)); }; populate_derived(); }

// Function implementations for IfcStructuralLoadSingleDisplacement
boost::optional< double > Ifc2x3::IfcStructuralLoadSingleDisplacement::DisplacementX() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcStructuralLoadSingleDisplacement::setDisplacementX(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadSingleDisplacement::DisplacementY() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcStructuralLoadSingleDisplacement::setDisplacementY(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadSingleDisplacement::DisplacementZ() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcStructuralLoadSingleDisplacement::setDisplacementZ(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadSingleDisplacement::RotationalDisplacementRX() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcStructuralLoadSingleDisplacement::setRotationalDisplacementRX(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadSingleDisplacement::RotationalDisplacementRY() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcStructuralLoadSingleDisplacement::setRotationalDisplacementRY(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadSingleDisplacement::RotationalDisplacementRZ() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcStructuralLoadSingleDisplacement::setRotationalDisplacementRZ(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }


const IfcParse::entity& Ifc2x3::IfcStructuralLoadSingleDisplacement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[818]); }
const IfcParse::entity& Ifc2x3::IfcStructuralLoadSingleDisplacement::Class() { return *((IfcParse::entity*)IFC2X3_types[818]); }
Ifc2x3::IfcStructuralLoadSingleDisplacement::IfcStructuralLoadSingleDisplacement(IfcEntityInstanceData&& e) : IfcStructuralLoadStatic(std::move(e)) { }
Ifc2x3::IfcStructuralLoadSingleDisplacement::IfcStructuralLoadSingleDisplacement(boost::optional< std::string > v1_Name, boost::optional< double > v2_DisplacementX, boost::optional< double > v3_DisplacementY, boost::optional< double > v4_DisplacementZ, boost::optional< double > v5_RotationalDisplacementRX, boost::optional< double > v6_RotationalDisplacementRY, boost::optional< double > v7_RotationalDisplacementRZ) : IfcStructuralLoadStatic(IfcEntityInstanceData(in_memory_attribute_storage(7))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_DisplacementX) {set_attribute_value(1, (*v2_DisplacementX)); } if (v3_DisplacementY) {set_attribute_value(2, (*v3_DisplacementY)); } if (v4_DisplacementZ) {set_attribute_value(3, (*v4_DisplacementZ)); } if (v5_RotationalDisplacementRX) {set_attribute_value(4, (*v5_RotationalDisplacementRX)); } if (v6_RotationalDisplacementRY) {set_attribute_value(5, (*v6_RotationalDisplacementRY)); } if (v7_RotationalDisplacementRZ) {set_attribute_value(6, (*v7_RotationalDisplacementRZ)); }; populate_derived(); }

// Function implementations for IfcStructuralLoadSingleDisplacementDistortion
boost::optional< double > Ifc2x3::IfcStructuralLoadSingleDisplacementDistortion::Distortion() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcStructuralLoadSingleDisplacementDistortion::setDistortion(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }


const IfcParse::entity& Ifc2x3::IfcStructuralLoadSingleDisplacementDistortion::declaration() const { return *((IfcParse::entity*)IFC2X3_types[819]); }
const IfcParse::entity& Ifc2x3::IfcStructuralLoadSingleDisplacementDistortion::Class() { return *((IfcParse::entity*)IFC2X3_types[819]); }
Ifc2x3::IfcStructuralLoadSingleDisplacementDistortion::IfcStructuralLoadSingleDisplacementDistortion(IfcEntityInstanceData&& e) : IfcStructuralLoadSingleDisplacement(std::move(e)) { }
Ifc2x3::IfcStructuralLoadSingleDisplacementDistortion::IfcStructuralLoadSingleDisplacementDistortion(boost::optional< std::string > v1_Name, boost::optional< double > v2_DisplacementX, boost::optional< double > v3_DisplacementY, boost::optional< double > v4_DisplacementZ, boost::optional< double > v5_RotationalDisplacementRX, boost::optional< double > v6_RotationalDisplacementRY, boost::optional< double > v7_RotationalDisplacementRZ, boost::optional< double > v8_Distortion) : IfcStructuralLoadSingleDisplacement(IfcEntityInstanceData(in_memory_attribute_storage(8))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_DisplacementX) {set_attribute_value(1, (*v2_DisplacementX)); } if (v3_DisplacementY) {set_attribute_value(2, (*v3_DisplacementY)); } if (v4_DisplacementZ) {set_attribute_value(3, (*v4_DisplacementZ)); } if (v5_RotationalDisplacementRX) {set_attribute_value(4, (*v5_RotationalDisplacementRX)); } if (v6_RotationalDisplacementRY) {set_attribute_value(5, (*v6_RotationalDisplacementRY)); } if (v7_RotationalDisplacementRZ) {set_attribute_value(6, (*v7_RotationalDisplacementRZ)); } if (v8_Distortion) {set_attribute_value(7, (*v8_Distortion)); }; populate_derived(); }

// Function implementations for IfcStructuralLoadSingleForce
boost::optional< double > Ifc2x3::IfcStructuralLoadSingleForce::ForceX() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcStructuralLoadSingleForce::setForceX(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadSingleForce::ForceY() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcStructuralLoadSingleForce::setForceY(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadSingleForce::ForceZ() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcStructuralLoadSingleForce::setForceZ(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadSingleForce::MomentX() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcStructuralLoadSingleForce::setMomentX(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadSingleForce::MomentY() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcStructuralLoadSingleForce::setMomentY(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadSingleForce::MomentZ() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcStructuralLoadSingleForce::setMomentZ(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }


const IfcParse::entity& Ifc2x3::IfcStructuralLoadSingleForce::declaration() const { return *((IfcParse::entity*)IFC2X3_types[820]); }
const IfcParse::entity& Ifc2x3::IfcStructuralLoadSingleForce::Class() { return *((IfcParse::entity*)IFC2X3_types[820]); }
Ifc2x3::IfcStructuralLoadSingleForce::IfcStructuralLoadSingleForce(IfcEntityInstanceData&& e) : IfcStructuralLoadStatic(std::move(e)) { }
Ifc2x3::IfcStructuralLoadSingleForce::IfcStructuralLoadSingleForce(boost::optional< std::string > v1_Name, boost::optional< double > v2_ForceX, boost::optional< double > v3_ForceY, boost::optional< double > v4_ForceZ, boost::optional< double > v5_MomentX, boost::optional< double > v6_MomentY, boost::optional< double > v7_MomentZ) : IfcStructuralLoadStatic(IfcEntityInstanceData(in_memory_attribute_storage(7))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_ForceX) {set_attribute_value(1, (*v2_ForceX)); } if (v3_ForceY) {set_attribute_value(2, (*v3_ForceY)); } if (v4_ForceZ) {set_attribute_value(3, (*v4_ForceZ)); } if (v5_MomentX) {set_attribute_value(4, (*v5_MomentX)); } if (v6_MomentY) {set_attribute_value(5, (*v6_MomentY)); } if (v7_MomentZ) {set_attribute_value(6, (*v7_MomentZ)); }; populate_derived(); }

// Function implementations for IfcStructuralLoadSingleForceWarping
boost::optional< double > Ifc2x3::IfcStructuralLoadSingleForceWarping::WarpingMoment() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcStructuralLoadSingleForceWarping::setWarpingMoment(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }


const IfcParse::entity& Ifc2x3::IfcStructuralLoadSingleForceWarping::declaration() const { return *((IfcParse::entity*)IFC2X3_types[821]); }
const IfcParse::entity& Ifc2x3::IfcStructuralLoadSingleForceWarping::Class() { return *((IfcParse::entity*)IFC2X3_types[821]); }
Ifc2x3::IfcStructuralLoadSingleForceWarping::IfcStructuralLoadSingleForceWarping(IfcEntityInstanceData&& e) : IfcStructuralLoadSingleForce(std::move(e)) { }
Ifc2x3::IfcStructuralLoadSingleForceWarping::IfcStructuralLoadSingleForceWarping(boost::optional< std::string > v1_Name, boost::optional< double > v2_ForceX, boost::optional< double > v3_ForceY, boost::optional< double > v4_ForceZ, boost::optional< double > v5_MomentX, boost::optional< double > v6_MomentY, boost::optional< double > v7_MomentZ, boost::optional< double > v8_WarpingMoment) : IfcStructuralLoadSingleForce(IfcEntityInstanceData(in_memory_attribute_storage(8))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_ForceX) {set_attribute_value(1, (*v2_ForceX)); } if (v3_ForceY) {set_attribute_value(2, (*v3_ForceY)); } if (v4_ForceZ) {set_attribute_value(3, (*v4_ForceZ)); } if (v5_MomentX) {set_attribute_value(4, (*v5_MomentX)); } if (v6_MomentY) {set_attribute_value(5, (*v6_MomentY)); } if (v7_MomentZ) {set_attribute_value(6, (*v7_MomentZ)); } if (v8_WarpingMoment) {set_attribute_value(7, (*v8_WarpingMoment)); }; populate_derived(); }

// Function implementations for IfcStructuralLoadStatic


const IfcParse::entity& Ifc2x3::IfcStructuralLoadStatic::declaration() const { return *((IfcParse::entity*)IFC2X3_types[822]); }
const IfcParse::entity& Ifc2x3::IfcStructuralLoadStatic::Class() { return *((IfcParse::entity*)IFC2X3_types[822]); }
Ifc2x3::IfcStructuralLoadStatic::IfcStructuralLoadStatic(IfcEntityInstanceData&& e) : IfcStructuralLoad(std::move(e)) { }
Ifc2x3::IfcStructuralLoadStatic::IfcStructuralLoadStatic(boost::optional< std::string > v1_Name) : IfcStructuralLoad(IfcEntityInstanceData(in_memory_attribute_storage(1))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }; populate_derived(); }

// Function implementations for IfcStructuralLoadTemperature
boost::optional< double > Ifc2x3::IfcStructuralLoadTemperature::DeltaT_Constant() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcStructuralLoadTemperature::setDeltaT_Constant(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadTemperature::DeltaT_Y() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcStructuralLoadTemperature::setDeltaT_Y(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcStructuralLoadTemperature::DeltaT_Z() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcStructuralLoadTemperature::setDeltaT_Z(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }


const IfcParse::entity& Ifc2x3::IfcStructuralLoadTemperature::declaration() const { return *((IfcParse::entity*)IFC2X3_types[823]); }
const IfcParse::entity& Ifc2x3::IfcStructuralLoadTemperature::Class() { return *((IfcParse::entity*)IFC2X3_types[823]); }
Ifc2x3::IfcStructuralLoadTemperature::IfcStructuralLoadTemperature(IfcEntityInstanceData&& e) : IfcStructuralLoadStatic(std::move(e)) { }
Ifc2x3::IfcStructuralLoadTemperature::IfcStructuralLoadTemperature(boost::optional< std::string > v1_Name, boost::optional< double > v2_DeltaT_Constant, boost::optional< double > v3_DeltaT_Y, boost::optional< double > v4_DeltaT_Z) : IfcStructuralLoadStatic(IfcEntityInstanceData(in_memory_attribute_storage(4))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_DeltaT_Constant) {set_attribute_value(1, (*v2_DeltaT_Constant)); } if (v3_DeltaT_Y) {set_attribute_value(2, (*v3_DeltaT_Y)); } if (v4_DeltaT_Z) {set_attribute_value(3, (*v4_DeltaT_Z)); }; populate_derived(); }

// Function implementations for IfcStructuralMember

::Ifc2x3::IfcRelConnectsStructuralElement::list::ptr Ifc2x3::IfcStructuralMember::ReferencesElement() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[694], 5)->as<IfcRelConnectsStructuralElement>(); }
::Ifc2x3::IfcRelConnectsStructuralMember::list::ptr Ifc2x3::IfcStructuralMember::ConnectedBy() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[695], 4)->as<IfcRelConnectsStructuralMember>(); }

const IfcParse::entity& Ifc2x3::IfcStructuralMember::declaration() const { return *((IfcParse::entity*)IFC2X3_types[824]); }
const IfcParse::entity& Ifc2x3::IfcStructuralMember::Class() { return *((IfcParse::entity*)IFC2X3_types[824]); }
Ifc2x3::IfcStructuralMember::IfcStructuralMember(IfcEntityInstanceData&& e) : IfcStructuralItem(std::move(e)) { }
Ifc2x3::IfcStructuralMember::IfcStructuralMember(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation) : IfcStructuralItem(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcStructuralPlanarAction
::Ifc2x3::IfcProjectedOrTrueLengthEnum::Value Ifc2x3::IfcStructuralPlanarAction::ProjectedOrTrue() const {  return ::Ifc2x3::IfcProjectedOrTrueLengthEnum::FromString(get_attribute_value(11)); }
void Ifc2x3::IfcStructuralPlanarAction::setProjectedOrTrue(::Ifc2x3::IfcProjectedOrTrueLengthEnum::Value v) { set_attribute_value(11, EnumerationReference(&::Ifc2x3::IfcProjectedOrTrueLengthEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(11); }


const IfcParse::entity& Ifc2x3::IfcStructuralPlanarAction::declaration() const { return *((IfcParse::entity*)IFC2X3_types[825]); }
const IfcParse::entity& Ifc2x3::IfcStructuralPlanarAction::Class() { return *((IfcParse::entity*)IFC2X3_types[825]); }
Ifc2x3::IfcStructuralPlanarAction::IfcStructuralPlanarAction(IfcEntityInstanceData&& e) : IfcStructuralAction(std::move(e)) { }
Ifc2x3::IfcStructuralPlanarAction::IfcStructuralPlanarAction(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcStructuralLoad* v8_AppliedLoad, ::Ifc2x3::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal, bool v10_DestabilizingLoad, ::Ifc2x3::IfcStructuralReaction* v11_CausedBy, ::Ifc2x3::IfcProjectedOrTrueLengthEnum::Value v12_ProjectedOrTrue) : IfcStructuralAction(IfcEntityInstanceData(in_memory_attribute_storage(12))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_AppliedLoad ? v8_AppliedLoad->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal)));set_attribute_value(9, (v10_DestabilizingLoad));set_attribute_value(10, v11_CausedBy ? v11_CausedBy->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(11, (EnumerationReference(&::Ifc2x3::IfcProjectedOrTrueLengthEnum::Class(),(size_t)v12_ProjectedOrTrue)));; populate_derived(); }

// Function implementations for IfcStructuralPlanarActionVarying
::Ifc2x3::IfcShapeAspect* Ifc2x3::IfcStructuralPlanarActionVarying::VaryingAppliedLoadLocation() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(12)))->as<::Ifc2x3::IfcShapeAspect>(true); }
void Ifc2x3::IfcStructuralPlanarActionVarying::setVaryingAppliedLoadLocation(::Ifc2x3::IfcShapeAspect* v) { set_attribute_value(12, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(12); }
aggregate_of< ::Ifc2x3::IfcStructuralLoad >::ptr Ifc2x3::IfcStructuralPlanarActionVarying::SubsequentAppliedLoads() const {  aggregate_of_instance::ptr es = get_attribute_value(13); return es->as< ::Ifc2x3::IfcStructuralLoad >(); }
void Ifc2x3::IfcStructuralPlanarActionVarying::setSubsequentAppliedLoads(aggregate_of< ::Ifc2x3::IfcStructuralLoad >::ptr v) { set_attribute_value(13, (v)->generalize());if constexpr (false)unset_attribute_value(13); }


const IfcParse::entity& Ifc2x3::IfcStructuralPlanarActionVarying::declaration() const { return *((IfcParse::entity*)IFC2X3_types[826]); }
const IfcParse::entity& Ifc2x3::IfcStructuralPlanarActionVarying::Class() { return *((IfcParse::entity*)IFC2X3_types[826]); }
Ifc2x3::IfcStructuralPlanarActionVarying::IfcStructuralPlanarActionVarying(IfcEntityInstanceData&& e) : IfcStructuralPlanarAction(std::move(e)) { }
Ifc2x3::IfcStructuralPlanarActionVarying::IfcStructuralPlanarActionVarying(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcStructuralLoad* v8_AppliedLoad, ::Ifc2x3::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal, bool v10_DestabilizingLoad, ::Ifc2x3::IfcStructuralReaction* v11_CausedBy, ::Ifc2x3::IfcProjectedOrTrueLengthEnum::Value v12_ProjectedOrTrue, ::Ifc2x3::IfcShapeAspect* v13_VaryingAppliedLoadLocation, aggregate_of< ::Ifc2x3::IfcStructuralLoad >::ptr v14_SubsequentAppliedLoads) : IfcStructuralPlanarAction(IfcEntityInstanceData(in_memory_attribute_storage(14))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_AppliedLoad ? v8_AppliedLoad->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal)));set_attribute_value(9, (v10_DestabilizingLoad));set_attribute_value(10, v11_CausedBy ? v11_CausedBy->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(11, (EnumerationReference(&::Ifc2x3::IfcProjectedOrTrueLengthEnum::Class(),(size_t)v12_ProjectedOrTrue)));set_attribute_value(12, v13_VaryingAppliedLoadLocation ? v13_VaryingAppliedLoadLocation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(13, (v14_SubsequentAppliedLoads)->generalize());; populate_derived(); }

// Function implementations for IfcStructuralPointAction


const IfcParse::entity& Ifc2x3::IfcStructuralPointAction::declaration() const { return *((IfcParse::entity*)IFC2X3_types[827]); }
const IfcParse::entity& Ifc2x3::IfcStructuralPointAction::Class() { return *((IfcParse::entity*)IFC2X3_types[827]); }
Ifc2x3::IfcStructuralPointAction::IfcStructuralPointAction(IfcEntityInstanceData&& e) : IfcStructuralAction(std::move(e)) { }
Ifc2x3::IfcStructuralPointAction::IfcStructuralPointAction(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcStructuralLoad* v8_AppliedLoad, ::Ifc2x3::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal, bool v10_DestabilizingLoad, ::Ifc2x3::IfcStructuralReaction* v11_CausedBy) : IfcStructuralAction(IfcEntityInstanceData(in_memory_attribute_storage(11))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_AppliedLoad ? v8_AppliedLoad->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal)));set_attribute_value(9, (v10_DestabilizingLoad));set_attribute_value(10, v11_CausedBy ? v11_CausedBy->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcStructuralPointConnection


const IfcParse::entity& Ifc2x3::IfcStructuralPointConnection::declaration() const { return *((IfcParse::entity*)IFC2X3_types[828]); }
const IfcParse::entity& Ifc2x3::IfcStructuralPointConnection::Class() { return *((IfcParse::entity*)IFC2X3_types[828]); }
Ifc2x3::IfcStructuralPointConnection::IfcStructuralPointConnection(IfcEntityInstanceData&& e) : IfcStructuralConnection(std::move(e)) { }
Ifc2x3::IfcStructuralPointConnection::IfcStructuralPointConnection(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcBoundaryCondition* v8_AppliedCondition) : IfcStructuralConnection(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_AppliedCondition ? v8_AppliedCondition->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcStructuralPointReaction


const IfcParse::entity& Ifc2x3::IfcStructuralPointReaction::declaration() const { return *((IfcParse::entity*)IFC2X3_types[829]); }
const IfcParse::entity& Ifc2x3::IfcStructuralPointReaction::Class() { return *((IfcParse::entity*)IFC2X3_types[829]); }
Ifc2x3::IfcStructuralPointReaction::IfcStructuralPointReaction(IfcEntityInstanceData&& e) : IfcStructuralReaction(std::move(e)) { }
Ifc2x3::IfcStructuralPointReaction::IfcStructuralPointReaction(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcStructuralLoad* v8_AppliedLoad, ::Ifc2x3::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal) : IfcStructuralReaction(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_AppliedLoad ? v8_AppliedLoad->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal)));; populate_derived(); }

// Function implementations for IfcStructuralProfileProperties
boost::optional< double > Ifc2x3::IfcStructuralProfileProperties::TorsionalConstantX() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcStructuralProfileProperties::setTorsionalConstantX(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
boost::optional< double > Ifc2x3::IfcStructuralProfileProperties::MomentOfInertiaYZ() const { if(get_attribute_value(8).isNull()) { return boost::none; } double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcStructuralProfileProperties::setMomentOfInertiaYZ(boost::optional< double > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
boost::optional< double > Ifc2x3::IfcStructuralProfileProperties::MomentOfInertiaY() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcStructuralProfileProperties::setMomentOfInertiaY(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
boost::optional< double > Ifc2x3::IfcStructuralProfileProperties::MomentOfInertiaZ() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcStructuralProfileProperties::setMomentOfInertiaZ(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
boost::optional< double > Ifc2x3::IfcStructuralProfileProperties::WarpingConstant() const { if(get_attribute_value(11).isNull()) { return boost::none; } double v = get_attribute_value(11); return v; }
void Ifc2x3::IfcStructuralProfileProperties::setWarpingConstant(boost::optional< double > v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
boost::optional< double > Ifc2x3::IfcStructuralProfileProperties::ShearCentreZ() const { if(get_attribute_value(12).isNull()) { return boost::none; } double v = get_attribute_value(12); return v; }
void Ifc2x3::IfcStructuralProfileProperties::setShearCentreZ(boost::optional< double > v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
boost::optional< double > Ifc2x3::IfcStructuralProfileProperties::ShearCentreY() const { if(get_attribute_value(13).isNull()) { return boost::none; } double v = get_attribute_value(13); return v; }
void Ifc2x3::IfcStructuralProfileProperties::setShearCentreY(boost::optional< double > v) { if (v) {set_attribute_value(13, *v);} else {unset_attribute_value(13);} }
boost::optional< double > Ifc2x3::IfcStructuralProfileProperties::ShearDeformationAreaZ() const { if(get_attribute_value(14).isNull()) { return boost::none; } double v = get_attribute_value(14); return v; }
void Ifc2x3::IfcStructuralProfileProperties::setShearDeformationAreaZ(boost::optional< double > v) { if (v) {set_attribute_value(14, *v);} else {unset_attribute_value(14);} }
boost::optional< double > Ifc2x3::IfcStructuralProfileProperties::ShearDeformationAreaY() const { if(get_attribute_value(15).isNull()) { return boost::none; } double v = get_attribute_value(15); return v; }
void Ifc2x3::IfcStructuralProfileProperties::setShearDeformationAreaY(boost::optional< double > v) { if (v) {set_attribute_value(15, *v);} else {unset_attribute_value(15);} }
boost::optional< double > Ifc2x3::IfcStructuralProfileProperties::MaximumSectionModulusY() const { if(get_attribute_value(16).isNull()) { return boost::none; } double v = get_attribute_value(16); return v; }
void Ifc2x3::IfcStructuralProfileProperties::setMaximumSectionModulusY(boost::optional< double > v) { if (v) {set_attribute_value(16, *v);} else {unset_attribute_value(16);} }
boost::optional< double > Ifc2x3::IfcStructuralProfileProperties::MinimumSectionModulusY() const { if(get_attribute_value(17).isNull()) { return boost::none; } double v = get_attribute_value(17); return v; }
void Ifc2x3::IfcStructuralProfileProperties::setMinimumSectionModulusY(boost::optional< double > v) { if (v) {set_attribute_value(17, *v);} else {unset_attribute_value(17);} }
boost::optional< double > Ifc2x3::IfcStructuralProfileProperties::MaximumSectionModulusZ() const { if(get_attribute_value(18).isNull()) { return boost::none; } double v = get_attribute_value(18); return v; }
void Ifc2x3::IfcStructuralProfileProperties::setMaximumSectionModulusZ(boost::optional< double > v) { if (v) {set_attribute_value(18, *v);} else {unset_attribute_value(18);} }
boost::optional< double > Ifc2x3::IfcStructuralProfileProperties::MinimumSectionModulusZ() const { if(get_attribute_value(19).isNull()) { return boost::none; } double v = get_attribute_value(19); return v; }
void Ifc2x3::IfcStructuralProfileProperties::setMinimumSectionModulusZ(boost::optional< double > v) { if (v) {set_attribute_value(19, *v);} else {unset_attribute_value(19);} }
boost::optional< double > Ifc2x3::IfcStructuralProfileProperties::TorsionalSectionModulus() const { if(get_attribute_value(20).isNull()) { return boost::none; } double v = get_attribute_value(20); return v; }
void Ifc2x3::IfcStructuralProfileProperties::setTorsionalSectionModulus(boost::optional< double > v) { if (v) {set_attribute_value(20, *v);} else {unset_attribute_value(20);} }
boost::optional< double > Ifc2x3::IfcStructuralProfileProperties::CentreOfGravityInX() const { if(get_attribute_value(21).isNull()) { return boost::none; } double v = get_attribute_value(21); return v; }
void Ifc2x3::IfcStructuralProfileProperties::setCentreOfGravityInX(boost::optional< double > v) { if (v) {set_attribute_value(21, *v);} else {unset_attribute_value(21);} }
boost::optional< double > Ifc2x3::IfcStructuralProfileProperties::CentreOfGravityInY() const { if(get_attribute_value(22).isNull()) { return boost::none; } double v = get_attribute_value(22); return v; }
void Ifc2x3::IfcStructuralProfileProperties::setCentreOfGravityInY(boost::optional< double > v) { if (v) {set_attribute_value(22, *v);} else {unset_attribute_value(22);} }


const IfcParse::entity& Ifc2x3::IfcStructuralProfileProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[830]); }
const IfcParse::entity& Ifc2x3::IfcStructuralProfileProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[830]); }
Ifc2x3::IfcStructuralProfileProperties::IfcStructuralProfileProperties(IfcEntityInstanceData&& e) : IfcGeneralProfileProperties(std::move(e)) { }
Ifc2x3::IfcStructuralProfileProperties::IfcStructuralProfileProperties(boost::optional< std::string > v1_ProfileName, ::Ifc2x3::IfcProfileDef* v2_ProfileDefinition, boost::optional< double > v3_PhysicalWeight, boost::optional< double > v4_Perimeter, boost::optional< double > v5_MinimumPlateThickness, boost::optional< double > v6_MaximumPlateThickness, boost::optional< double > v7_CrossSectionArea, boost::optional< double > v8_TorsionalConstantX, boost::optional< double > v9_MomentOfInertiaYZ, boost::optional< double > v10_MomentOfInertiaY, boost::optional< double > v11_MomentOfInertiaZ, boost::optional< double > v12_WarpingConstant, boost::optional< double > v13_ShearCentreZ, boost::optional< double > v14_ShearCentreY, boost::optional< double > v15_ShearDeformationAreaZ, boost::optional< double > v16_ShearDeformationAreaY, boost::optional< double > v17_MaximumSectionModulusY, boost::optional< double > v18_MinimumSectionModulusY, boost::optional< double > v19_MaximumSectionModulusZ, boost::optional< double > v20_MinimumSectionModulusZ, boost::optional< double > v21_TorsionalSectionModulus, boost::optional< double > v22_CentreOfGravityInX, boost::optional< double > v23_CentreOfGravityInY) : IfcGeneralProfileProperties(IfcEntityInstanceData(in_memory_attribute_storage(23))) {  if (v1_ProfileName) {set_attribute_value(0, (*v1_ProfileName)); }set_attribute_value(1, v2_ProfileDefinition ? v2_ProfileDefinition->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_PhysicalWeight) {set_attribute_value(2, (*v3_PhysicalWeight)); } if (v4_Perimeter) {set_attribute_value(3, (*v4_Perimeter)); } if (v5_MinimumPlateThickness) {set_attribute_value(4, (*v5_MinimumPlateThickness)); } if (v6_MaximumPlateThickness) {set_attribute_value(5, (*v6_MaximumPlateThickness)); } if (v7_CrossSectionArea) {set_attribute_value(6, (*v7_CrossSectionArea)); } if (v8_TorsionalConstantX) {set_attribute_value(7, (*v8_TorsionalConstantX)); } if (v9_MomentOfInertiaYZ) {set_attribute_value(8, (*v9_MomentOfInertiaYZ)); } if (v10_MomentOfInertiaY) {set_attribute_value(9, (*v10_MomentOfInertiaY)); } if (v11_MomentOfInertiaZ) {set_attribute_value(10, (*v11_MomentOfInertiaZ)); } if (v12_WarpingConstant) {set_attribute_value(11, (*v12_WarpingConstant)); } if (v13_ShearCentreZ) {set_attribute_value(12, (*v13_ShearCentreZ)); } if (v14_ShearCentreY) {set_attribute_value(13, (*v14_ShearCentreY)); } if (v15_ShearDeformationAreaZ) {set_attribute_value(14, (*v15_ShearDeformationAreaZ)); } if (v16_ShearDeformationAreaY) {set_attribute_value(15, (*v16_ShearDeformationAreaY)); } if (v17_MaximumSectionModulusY) {set_attribute_value(16, (*v17_MaximumSectionModulusY)); } if (v18_MinimumSectionModulusY) {set_attribute_value(17, (*v18_MinimumSectionModulusY)); } if (v19_MaximumSectionModulusZ) {set_attribute_value(18, (*v19_MaximumSectionModulusZ)); } if (v20_MinimumSectionModulusZ) {set_attribute_value(19, (*v20_MinimumSectionModulusZ)); } if (v21_TorsionalSectionModulus) {set_attribute_value(20, (*v21_TorsionalSectionModulus)); } if (v22_CentreOfGravityInX) {set_attribute_value(21, (*v22_CentreOfGravityInX)); } if (v23_CentreOfGravityInY) {set_attribute_value(22, (*v23_CentreOfGravityInY)); }; populate_derived(); }

// Function implementations for IfcStructuralReaction

::Ifc2x3::IfcStructuralAction::list::ptr Ifc2x3::IfcStructuralReaction::Causes() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[801], 10)->as<IfcStructuralAction>(); }

const IfcParse::entity& Ifc2x3::IfcStructuralReaction::declaration() const { return *((IfcParse::entity*)IFC2X3_types[831]); }
const IfcParse::entity& Ifc2x3::IfcStructuralReaction::Class() { return *((IfcParse::entity*)IFC2X3_types[831]); }
Ifc2x3::IfcStructuralReaction::IfcStructuralReaction(IfcEntityInstanceData&& e) : IfcStructuralActivity(std::move(e)) { }
Ifc2x3::IfcStructuralReaction::IfcStructuralReaction(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcStructuralLoad* v8_AppliedLoad, ::Ifc2x3::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal) : IfcStructuralActivity(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_AppliedLoad ? v8_AppliedLoad->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal)));; populate_derived(); }

// Function implementations for IfcStructuralResultGroup
::Ifc2x3::IfcAnalysisTheoryTypeEnum::Value Ifc2x3::IfcStructuralResultGroup::TheoryType() const {  return ::Ifc2x3::IfcAnalysisTheoryTypeEnum::FromString(get_attribute_value(5)); }
void Ifc2x3::IfcStructuralResultGroup::setTheoryType(::Ifc2x3::IfcAnalysisTheoryTypeEnum::Value v) { set_attribute_value(5, EnumerationReference(&::Ifc2x3::IfcAnalysisTheoryTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcStructuralLoadGroup* Ifc2x3::IfcStructuralResultGroup::ResultForLoadGroup() const { if(get_attribute_value(6).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcStructuralLoadGroup>(true); }
void Ifc2x3::IfcStructuralResultGroup::setResultForLoadGroup(::Ifc2x3::IfcStructuralLoadGroup* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
bool Ifc2x3::IfcStructuralResultGroup::IsLinear() const {  bool v = get_attribute_value(7); return v; }
void Ifc2x3::IfcStructuralResultGroup::setIsLinear(bool v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }

::Ifc2x3::IfcStructuralAnalysisModel::list::ptr Ifc2x3::IfcStructuralResultGroup::ResultGroupFor() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[804], 8)->as<IfcStructuralAnalysisModel>(); }

const IfcParse::entity& Ifc2x3::IfcStructuralResultGroup::declaration() const { return *((IfcParse::entity*)IFC2X3_types[832]); }
const IfcParse::entity& Ifc2x3::IfcStructuralResultGroup::Class() { return *((IfcParse::entity*)IFC2X3_types[832]); }
Ifc2x3::IfcStructuralResultGroup::IfcStructuralResultGroup(IfcEntityInstanceData&& e) : IfcGroup(std::move(e)) { }
Ifc2x3::IfcStructuralResultGroup::IfcStructuralResultGroup(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcAnalysisTheoryTypeEnum::Value v6_TheoryType, ::Ifc2x3::IfcStructuralLoadGroup* v7_ResultForLoadGroup, bool v8_IsLinear) : IfcGroup(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcAnalysisTheoryTypeEnum::Class(),(size_t)v6_TheoryType)));set_attribute_value(6, v7_ResultForLoadGroup ? v7_ResultForLoadGroup->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, (v8_IsLinear));; populate_derived(); }

// Function implementations for IfcStructuralSteelProfileProperties
boost::optional< double > Ifc2x3::IfcStructuralSteelProfileProperties::ShearAreaZ() const { if(get_attribute_value(23).isNull()) { return boost::none; } double v = get_attribute_value(23); return v; }
void Ifc2x3::IfcStructuralSteelProfileProperties::setShearAreaZ(boost::optional< double > v) { if (v) {set_attribute_value(23, *v);} else {unset_attribute_value(23);} }
boost::optional< double > Ifc2x3::IfcStructuralSteelProfileProperties::ShearAreaY() const { if(get_attribute_value(24).isNull()) { return boost::none; } double v = get_attribute_value(24); return v; }
void Ifc2x3::IfcStructuralSteelProfileProperties::setShearAreaY(boost::optional< double > v) { if (v) {set_attribute_value(24, *v);} else {unset_attribute_value(24);} }
boost::optional< double > Ifc2x3::IfcStructuralSteelProfileProperties::PlasticShapeFactorY() const { if(get_attribute_value(25).isNull()) { return boost::none; } double v = get_attribute_value(25); return v; }
void Ifc2x3::IfcStructuralSteelProfileProperties::setPlasticShapeFactorY(boost::optional< double > v) { if (v) {set_attribute_value(25, *v);} else {unset_attribute_value(25);} }
boost::optional< double > Ifc2x3::IfcStructuralSteelProfileProperties::PlasticShapeFactorZ() const { if(get_attribute_value(26).isNull()) { return boost::none; } double v = get_attribute_value(26); return v; }
void Ifc2x3::IfcStructuralSteelProfileProperties::setPlasticShapeFactorZ(boost::optional< double > v) { if (v) {set_attribute_value(26, *v);} else {unset_attribute_value(26);} }


const IfcParse::entity& Ifc2x3::IfcStructuralSteelProfileProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[833]); }
const IfcParse::entity& Ifc2x3::IfcStructuralSteelProfileProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[833]); }
Ifc2x3::IfcStructuralSteelProfileProperties::IfcStructuralSteelProfileProperties(IfcEntityInstanceData&& e) : IfcStructuralProfileProperties(std::move(e)) { }
Ifc2x3::IfcStructuralSteelProfileProperties::IfcStructuralSteelProfileProperties(boost::optional< std::string > v1_ProfileName, ::Ifc2x3::IfcProfileDef* v2_ProfileDefinition, boost::optional< double > v3_PhysicalWeight, boost::optional< double > v4_Perimeter, boost::optional< double > v5_MinimumPlateThickness, boost::optional< double > v6_MaximumPlateThickness, boost::optional< double > v7_CrossSectionArea, boost::optional< double > v8_TorsionalConstantX, boost::optional< double > v9_MomentOfInertiaYZ, boost::optional< double > v10_MomentOfInertiaY, boost::optional< double > v11_MomentOfInertiaZ, boost::optional< double > v12_WarpingConstant, boost::optional< double > v13_ShearCentreZ, boost::optional< double > v14_ShearCentreY, boost::optional< double > v15_ShearDeformationAreaZ, boost::optional< double > v16_ShearDeformationAreaY, boost::optional< double > v17_MaximumSectionModulusY, boost::optional< double > v18_MinimumSectionModulusY, boost::optional< double > v19_MaximumSectionModulusZ, boost::optional< double > v20_MinimumSectionModulusZ, boost::optional< double > v21_TorsionalSectionModulus, boost::optional< double > v22_CentreOfGravityInX, boost::optional< double > v23_CentreOfGravityInY, boost::optional< double > v24_ShearAreaZ, boost::optional< double > v25_ShearAreaY, boost::optional< double > v26_PlasticShapeFactorY, boost::optional< double > v27_PlasticShapeFactorZ) : IfcStructuralProfileProperties(IfcEntityInstanceData(in_memory_attribute_storage(27))) {  if (v1_ProfileName) {set_attribute_value(0, (*v1_ProfileName)); }set_attribute_value(1, v2_ProfileDefinition ? v2_ProfileDefinition->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_PhysicalWeight) {set_attribute_value(2, (*v3_PhysicalWeight)); } if (v4_Perimeter) {set_attribute_value(3, (*v4_Perimeter)); } if (v5_MinimumPlateThickness) {set_attribute_value(4, (*v5_MinimumPlateThickness)); } if (v6_MaximumPlateThickness) {set_attribute_value(5, (*v6_MaximumPlateThickness)); } if (v7_CrossSectionArea) {set_attribute_value(6, (*v7_CrossSectionArea)); } if (v8_TorsionalConstantX) {set_attribute_value(7, (*v8_TorsionalConstantX)); } if (v9_MomentOfInertiaYZ) {set_attribute_value(8, (*v9_MomentOfInertiaYZ)); } if (v10_MomentOfInertiaY) {set_attribute_value(9, (*v10_MomentOfInertiaY)); } if (v11_MomentOfInertiaZ) {set_attribute_value(10, (*v11_MomentOfInertiaZ)); } if (v12_WarpingConstant) {set_attribute_value(11, (*v12_WarpingConstant)); } if (v13_ShearCentreZ) {set_attribute_value(12, (*v13_ShearCentreZ)); } if (v14_ShearCentreY) {set_attribute_value(13, (*v14_ShearCentreY)); } if (v15_ShearDeformationAreaZ) {set_attribute_value(14, (*v15_ShearDeformationAreaZ)); } if (v16_ShearDeformationAreaY) {set_attribute_value(15, (*v16_ShearDeformationAreaY)); } if (v17_MaximumSectionModulusY) {set_attribute_value(16, (*v17_MaximumSectionModulusY)); } if (v18_MinimumSectionModulusY) {set_attribute_value(17, (*v18_MinimumSectionModulusY)); } if (v19_MaximumSectionModulusZ) {set_attribute_value(18, (*v19_MaximumSectionModulusZ)); } if (v20_MinimumSectionModulusZ) {set_attribute_value(19, (*v20_MinimumSectionModulusZ)); } if (v21_TorsionalSectionModulus) {set_attribute_value(20, (*v21_TorsionalSectionModulus)); } if (v22_CentreOfGravityInX) {set_attribute_value(21, (*v22_CentreOfGravityInX)); } if (v23_CentreOfGravityInY) {set_attribute_value(22, (*v23_CentreOfGravityInY)); } if (v24_ShearAreaZ) {set_attribute_value(23, (*v24_ShearAreaZ)); } if (v25_ShearAreaY) {set_attribute_value(24, (*v25_ShearAreaY)); } if (v26_PlasticShapeFactorY) {set_attribute_value(25, (*v26_PlasticShapeFactorY)); } if (v27_PlasticShapeFactorZ) {set_attribute_value(26, (*v27_PlasticShapeFactorZ)); }; populate_derived(); }

// Function implementations for IfcStructuralSurfaceConnection


const IfcParse::entity& Ifc2x3::IfcStructuralSurfaceConnection::declaration() const { return *((IfcParse::entity*)IFC2X3_types[834]); }
const IfcParse::entity& Ifc2x3::IfcStructuralSurfaceConnection::Class() { return *((IfcParse::entity*)IFC2X3_types[834]); }
Ifc2x3::IfcStructuralSurfaceConnection::IfcStructuralSurfaceConnection(IfcEntityInstanceData&& e) : IfcStructuralConnection(std::move(e)) { }
Ifc2x3::IfcStructuralSurfaceConnection::IfcStructuralSurfaceConnection(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcBoundaryCondition* v8_AppliedCondition) : IfcStructuralConnection(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_AppliedCondition ? v8_AppliedCondition->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcStructuralSurfaceMember
::Ifc2x3::IfcStructuralSurfaceTypeEnum::Value Ifc2x3::IfcStructuralSurfaceMember::PredefinedType() const {  return ::Ifc2x3::IfcStructuralSurfaceTypeEnum::FromString(get_attribute_value(7)); }
void Ifc2x3::IfcStructuralSurfaceMember::setPredefinedType(::Ifc2x3::IfcStructuralSurfaceTypeEnum::Value v) { set_attribute_value(7, EnumerationReference(&::Ifc2x3::IfcStructuralSurfaceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }
boost::optional< double > Ifc2x3::IfcStructuralSurfaceMember::Thickness() const { if(get_attribute_value(8).isNull()) { return boost::none; } double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcStructuralSurfaceMember::setThickness(boost::optional< double > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }


const IfcParse::entity& Ifc2x3::IfcStructuralSurfaceMember::declaration() const { return *((IfcParse::entity*)IFC2X3_types[835]); }
const IfcParse::entity& Ifc2x3::IfcStructuralSurfaceMember::Class() { return *((IfcParse::entity*)IFC2X3_types[835]); }
Ifc2x3::IfcStructuralSurfaceMember::IfcStructuralSurfaceMember(IfcEntityInstanceData&& e) : IfcStructuralMember(std::move(e)) { }
Ifc2x3::IfcStructuralSurfaceMember::IfcStructuralSurfaceMember(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcStructuralSurfaceTypeEnum::Value v8_PredefinedType, boost::optional< double > v9_Thickness) : IfcStructuralMember(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcStructuralSurfaceTypeEnum::Class(),(size_t)v8_PredefinedType))); if (v9_Thickness) {set_attribute_value(8, (*v9_Thickness)); }; populate_derived(); }

// Function implementations for IfcStructuralSurfaceMemberVarying
std::vector< double > /*[2:?]*/ Ifc2x3::IfcStructuralSurfaceMemberVarying::SubsequentThickness() const {  std::vector< double > /*[2:?]*/ v = get_attribute_value(9); return v; }
void Ifc2x3::IfcStructuralSurfaceMemberVarying::setSubsequentThickness(std::vector< double > /*[2:?]*/ v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }
::Ifc2x3::IfcShapeAspect* Ifc2x3::IfcStructuralSurfaceMemberVarying::VaryingThicknessLocation() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(10)))->as<::Ifc2x3::IfcShapeAspect>(true); }
void Ifc2x3::IfcStructuralSurfaceMemberVarying::setVaryingThicknessLocation(::Ifc2x3::IfcShapeAspect* v) { set_attribute_value(10, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(10); }


const IfcParse::entity& Ifc2x3::IfcStructuralSurfaceMemberVarying::declaration() const { return *((IfcParse::entity*)IFC2X3_types[836]); }
const IfcParse::entity& Ifc2x3::IfcStructuralSurfaceMemberVarying::Class() { return *((IfcParse::entity*)IFC2X3_types[836]); }
Ifc2x3::IfcStructuralSurfaceMemberVarying::IfcStructuralSurfaceMemberVarying(IfcEntityInstanceData&& e) : IfcStructuralSurfaceMember(std::move(e)) { }
Ifc2x3::IfcStructuralSurfaceMemberVarying::IfcStructuralSurfaceMemberVarying(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, ::Ifc2x3::IfcStructuralSurfaceTypeEnum::Value v8_PredefinedType, boost::optional< double > v9_Thickness, std::vector< double > /*[2:?]*/ v10_SubsequentThickness, ::Ifc2x3::IfcShapeAspect* v11_VaryingThicknessLocation) : IfcStructuralSurfaceMember(IfcEntityInstanceData(in_memory_attribute_storage(11))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcStructuralSurfaceTypeEnum::Class(),(size_t)v8_PredefinedType))); if (v9_Thickness) {set_attribute_value(8, (*v9_Thickness)); }set_attribute_value(9, (v10_SubsequentThickness));set_attribute_value(10, v11_VaryingThicknessLocation ? v11_VaryingThicknessLocation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcStructuredDimensionCallout


const IfcParse::entity& Ifc2x3::IfcStructuredDimensionCallout::declaration() const { return *((IfcParse::entity*)IFC2X3_types[838]); }
const IfcParse::entity& Ifc2x3::IfcStructuredDimensionCallout::Class() { return *((IfcParse::entity*)IFC2X3_types[838]); }
Ifc2x3::IfcStructuredDimensionCallout::IfcStructuredDimensionCallout(IfcEntityInstanceData&& e) : IfcDraughtingCallout(std::move(e)) { }
Ifc2x3::IfcStructuredDimensionCallout::IfcStructuredDimensionCallout(aggregate_of< ::Ifc2x3::IfcDraughtingCalloutElement >::ptr v1_Contents) : IfcDraughtingCallout(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Contents)->generalize());; populate_derived(); }

// Function implementations for IfcStyleModel


const IfcParse::entity& Ifc2x3::IfcStyleModel::declaration() const { return *((IfcParse::entity*)IFC2X3_types[841]); }
const IfcParse::entity& Ifc2x3::IfcStyleModel::Class() { return *((IfcParse::entity*)IFC2X3_types[841]); }
Ifc2x3::IfcStyleModel::IfcStyleModel(IfcEntityInstanceData&& e) : IfcRepresentation(std::move(e)) { }
Ifc2x3::IfcStyleModel::IfcStyleModel(::Ifc2x3::IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, aggregate_of< ::Ifc2x3::IfcRepresentationItem >::ptr v4_Items) : IfcRepresentation(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_ContextOfItems ? v1_ContextOfItems->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_RepresentationIdentifier) {set_attribute_value(1, (*v2_RepresentationIdentifier)); } if (v3_RepresentationType) {set_attribute_value(2, (*v3_RepresentationType)); }set_attribute_value(3, (v4_Items)->generalize());; populate_derived(); }

// Function implementations for IfcStyledItem
::Ifc2x3::IfcRepresentationItem* Ifc2x3::IfcStyledItem::Item() const { if(get_attribute_value(0).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcRepresentationItem>(true); }
void Ifc2x3::IfcStyledItem::setItem(::Ifc2x3::IfcRepresentationItem* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcPresentationStyleAssignment >::ptr Ifc2x3::IfcStyledItem::Styles() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcPresentationStyleAssignment >(); }
void Ifc2x3::IfcStyledItem::setStyles(aggregate_of< ::Ifc2x3::IfcPresentationStyleAssignment >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }
boost::optional< std::string > Ifc2x3::IfcStyledItem::Name() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcStyledItem::setName(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }


const IfcParse::entity& Ifc2x3::IfcStyledItem::declaration() const { return *((IfcParse::entity*)IFC2X3_types[839]); }
const IfcParse::entity& Ifc2x3::IfcStyledItem::Class() { return *((IfcParse::entity*)IFC2X3_types[839]); }
Ifc2x3::IfcStyledItem::IfcStyledItem(IfcEntityInstanceData&& e) : IfcRepresentationItem(std::move(e)) { }
Ifc2x3::IfcStyledItem::IfcStyledItem(::Ifc2x3::IfcRepresentationItem* v1_Item, aggregate_of< ::Ifc2x3::IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name) : IfcRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_Item ? v1_Item->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Styles)->generalize()); if (v3_Name) {set_attribute_value(2, (*v3_Name)); }; populate_derived(); }

// Function implementations for IfcStyledRepresentation


const IfcParse::entity& Ifc2x3::IfcStyledRepresentation::declaration() const { return *((IfcParse::entity*)IFC2X3_types[840]); }
const IfcParse::entity& Ifc2x3::IfcStyledRepresentation::Class() { return *((IfcParse::entity*)IFC2X3_types[840]); }
Ifc2x3::IfcStyledRepresentation::IfcStyledRepresentation(IfcEntityInstanceData&& e) : IfcStyleModel(std::move(e)) { }
Ifc2x3::IfcStyledRepresentation::IfcStyledRepresentation(::Ifc2x3::IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, aggregate_of< ::Ifc2x3::IfcRepresentationItem >::ptr v4_Items) : IfcStyleModel(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_ContextOfItems ? v1_ContextOfItems->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_RepresentationIdentifier) {set_attribute_value(1, (*v2_RepresentationIdentifier)); } if (v3_RepresentationType) {set_attribute_value(2, (*v3_RepresentationType)); }set_attribute_value(3, (v4_Items)->generalize());; populate_derived(); }

// Function implementations for IfcSubContractResource
::Ifc2x3::IfcActorSelect* Ifc2x3::IfcSubContractResource::SubContractor() const { if(get_attribute_value(9).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(9)))->as<::Ifc2x3::IfcActorSelect>(true); }
void Ifc2x3::IfcSubContractResource::setSubContractor(::Ifc2x3::IfcActorSelect* v) { set_attribute_value(9, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(9); }
boost::optional< std::string > Ifc2x3::IfcSubContractResource::JobDescription() const { if(get_attribute_value(10).isNull()) { return boost::none; } std::string v = get_attribute_value(10); return v; }
void Ifc2x3::IfcSubContractResource::setJobDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }


const IfcParse::entity& Ifc2x3::IfcSubContractResource::declaration() const { return *((IfcParse::entity*)IFC2X3_types[842]); }
const IfcParse::entity& Ifc2x3::IfcSubContractResource::Class() { return *((IfcParse::entity*)IFC2X3_types[842]); }
Ifc2x3::IfcSubContractResource::IfcSubContractResource(IfcEntityInstanceData&& e) : IfcConstructionResource(std::move(e)) { }
Ifc2x3::IfcSubContractResource::IfcSubContractResource(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< std::string > v6_ResourceIdentifier, boost::optional< std::string > v7_ResourceGroup, boost::optional< ::Ifc2x3::IfcResourceConsumptionEnum::Value > v8_ResourceConsumption, ::Ifc2x3::IfcMeasureWithUnit* v9_BaseQuantity, ::Ifc2x3::IfcActorSelect* v10_SubContractor, boost::optional< std::string > v11_JobDescription) : IfcConstructionResource(IfcEntityInstanceData(in_memory_attribute_storage(11))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); } if (v6_ResourceIdentifier) {set_attribute_value(5, (*v6_ResourceIdentifier)); } if (v7_ResourceGroup) {set_attribute_value(6, (*v7_ResourceGroup)); } if (v8_ResourceConsumption) {set_attribute_value(7, (EnumerationReference(&::Ifc2x3::IfcResourceConsumptionEnum::Class(),(size_t)*v8_ResourceConsumption))); }set_attribute_value(8, v9_BaseQuantity ? v9_BaseQuantity->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(9, v10_SubContractor ? v10_SubContractor->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v11_JobDescription) {set_attribute_value(10, (*v11_JobDescription)); }; populate_derived(); }

// Function implementations for IfcSubedge
::Ifc2x3::IfcEdge* Ifc2x3::IfcSubedge::ParentEdge() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcEdge>(true); }
void Ifc2x3::IfcSubedge::setParentEdge(::Ifc2x3::IfcEdge* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcSubedge::declaration() const { return *((IfcParse::entity*)IFC2X3_types[843]); }
const IfcParse::entity& Ifc2x3::IfcSubedge::Class() { return *((IfcParse::entity*)IFC2X3_types[843]); }
Ifc2x3::IfcSubedge::IfcSubedge(IfcEntityInstanceData&& e) : IfcEdge(std::move(e)) { }
Ifc2x3::IfcSubedge::IfcSubedge(::Ifc2x3::IfcVertex* v1_EdgeStart, ::Ifc2x3::IfcVertex* v2_EdgeEnd, ::Ifc2x3::IfcEdge* v3_ParentEdge) : IfcEdge(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_EdgeStart ? v1_EdgeStart->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_EdgeEnd ? v2_EdgeEnd->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_ParentEdge ? v3_ParentEdge->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcSurface


const IfcParse::entity& Ifc2x3::IfcSurface::declaration() const { return *((IfcParse::entity*)IFC2X3_types[844]); }
const IfcParse::entity& Ifc2x3::IfcSurface::Class() { return *((IfcParse::entity*)IFC2X3_types[844]); }
Ifc2x3::IfcSurface::IfcSurface(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcSurface::IfcSurface() : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(0))) { ; populate_derived(); }

// Function implementations for IfcSurfaceCurveSweptAreaSolid
::Ifc2x3::IfcCurve* Ifc2x3::IfcSurfaceCurveSweptAreaSolid::Directrix() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcCurve>(true); }
void Ifc2x3::IfcSurfaceCurveSweptAreaSolid::setDirectrix(::Ifc2x3::IfcCurve* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
double Ifc2x3::IfcSurfaceCurveSweptAreaSolid::StartParam() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcSurfaceCurveSweptAreaSolid::setStartParam(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
double Ifc2x3::IfcSurfaceCurveSweptAreaSolid::EndParam() const {  double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcSurfaceCurveSweptAreaSolid::setEndParam(double v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcSurface* Ifc2x3::IfcSurfaceCurveSweptAreaSolid::ReferenceSurface() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcSurface>(true); }
void Ifc2x3::IfcSurfaceCurveSweptAreaSolid::setReferenceSurface(::Ifc2x3::IfcSurface* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcSurfaceCurveSweptAreaSolid::declaration() const { return *((IfcParse::entity*)IFC2X3_types[845]); }
const IfcParse::entity& Ifc2x3::IfcSurfaceCurveSweptAreaSolid::Class() { return *((IfcParse::entity*)IFC2X3_types[845]); }
Ifc2x3::IfcSurfaceCurveSweptAreaSolid::IfcSurfaceCurveSweptAreaSolid(IfcEntityInstanceData&& e) : IfcSweptAreaSolid(std::move(e)) { }
Ifc2x3::IfcSurfaceCurveSweptAreaSolid::IfcSurfaceCurveSweptAreaSolid(::Ifc2x3::IfcProfileDef* v1_SweptArea, ::Ifc2x3::IfcAxis2Placement3D* v2_Position, ::Ifc2x3::IfcCurve* v3_Directrix, double v4_StartParam, double v5_EndParam, ::Ifc2x3::IfcSurface* v6_ReferenceSurface) : IfcSweptAreaSolid(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, v1_SweptArea ? v1_SweptArea->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_Position ? v2_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_Directrix ? v3_Directrix->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_StartParam));set_attribute_value(4, (v5_EndParam));set_attribute_value(5, v6_ReferenceSurface ? v6_ReferenceSurface->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcSurfaceOfLinearExtrusion
::Ifc2x3::IfcDirection* Ifc2x3::IfcSurfaceOfLinearExtrusion::ExtrudedDirection() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcDirection>(true); }
void Ifc2x3::IfcSurfaceOfLinearExtrusion::setExtrudedDirection(::Ifc2x3::IfcDirection* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
double Ifc2x3::IfcSurfaceOfLinearExtrusion::Depth() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcSurfaceOfLinearExtrusion::setDepth(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcSurfaceOfLinearExtrusion::declaration() const { return *((IfcParse::entity*)IFC2X3_types[846]); }
const IfcParse::entity& Ifc2x3::IfcSurfaceOfLinearExtrusion::Class() { return *((IfcParse::entity*)IFC2X3_types[846]); }
Ifc2x3::IfcSurfaceOfLinearExtrusion::IfcSurfaceOfLinearExtrusion(IfcEntityInstanceData&& e) : IfcSweptSurface(std::move(e)) { }
Ifc2x3::IfcSurfaceOfLinearExtrusion::IfcSurfaceOfLinearExtrusion(::Ifc2x3::IfcProfileDef* v1_SweptCurve, ::Ifc2x3::IfcAxis2Placement3D* v2_Position, ::Ifc2x3::IfcDirection* v3_ExtrudedDirection, double v4_Depth) : IfcSweptSurface(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_SweptCurve ? v1_SweptCurve->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_Position ? v2_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_ExtrudedDirection ? v3_ExtrudedDirection->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_Depth));; populate_derived(); }

// Function implementations for IfcSurfaceOfRevolution
::Ifc2x3::IfcAxis1Placement* Ifc2x3::IfcSurfaceOfRevolution::AxisPosition() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcAxis1Placement>(true); }
void Ifc2x3::IfcSurfaceOfRevolution::setAxisPosition(::Ifc2x3::IfcAxis1Placement* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcSurfaceOfRevolution::declaration() const { return *((IfcParse::entity*)IFC2X3_types[847]); }
const IfcParse::entity& Ifc2x3::IfcSurfaceOfRevolution::Class() { return *((IfcParse::entity*)IFC2X3_types[847]); }
Ifc2x3::IfcSurfaceOfRevolution::IfcSurfaceOfRevolution(IfcEntityInstanceData&& e) : IfcSweptSurface(std::move(e)) { }
Ifc2x3::IfcSurfaceOfRevolution::IfcSurfaceOfRevolution(::Ifc2x3::IfcProfileDef* v1_SweptCurve, ::Ifc2x3::IfcAxis2Placement3D* v2_Position, ::Ifc2x3::IfcAxis1Placement* v3_AxisPosition) : IfcSweptSurface(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, v1_SweptCurve ? v1_SweptCurve->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_Position ? v2_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_AxisPosition ? v3_AxisPosition->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcSurfaceStyle
::Ifc2x3::IfcSurfaceSide::Value Ifc2x3::IfcSurfaceStyle::Side() const {  return ::Ifc2x3::IfcSurfaceSide::FromString(get_attribute_value(1)); }
void Ifc2x3::IfcSurfaceStyle::setSide(::Ifc2x3::IfcSurfaceSide::Value v) { set_attribute_value(1, EnumerationReference(&::Ifc2x3::IfcSurfaceSide::Class(), (size_t) v));if constexpr (false)unset_attribute_value(1); }
aggregate_of< ::Ifc2x3::IfcSurfaceStyleElementSelect >::ptr Ifc2x3::IfcSurfaceStyle::Styles() const {  aggregate_of_instance::ptr es = get_attribute_value(2); return es->as< ::Ifc2x3::IfcSurfaceStyleElementSelect >(); }
void Ifc2x3::IfcSurfaceStyle::setStyles(aggregate_of< ::Ifc2x3::IfcSurfaceStyleElementSelect >::ptr v) { set_attribute_value(2, (v)->generalize());if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcSurfaceStyle::declaration() const { return *((IfcParse::entity*)IFC2X3_types[850]); }
const IfcParse::entity& Ifc2x3::IfcSurfaceStyle::Class() { return *((IfcParse::entity*)IFC2X3_types[850]); }
Ifc2x3::IfcSurfaceStyle::IfcSurfaceStyle(IfcEntityInstanceData&& e) : IfcPresentationStyle(std::move(e)) { }
Ifc2x3::IfcSurfaceStyle::IfcSurfaceStyle(boost::optional< std::string > v1_Name, ::Ifc2x3::IfcSurfaceSide::Value v2_Side, aggregate_of< ::Ifc2x3::IfcSurfaceStyleElementSelect >::ptr v3_Styles) : IfcPresentationStyle(IfcEntityInstanceData(in_memory_attribute_storage(3))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (EnumerationReference(&::Ifc2x3::IfcSurfaceSide::Class(),(size_t)v2_Side)));set_attribute_value(2, (v3_Styles)->generalize());; populate_derived(); }

// Function implementations for IfcSurfaceStyleLighting
::Ifc2x3::IfcColourRgb* Ifc2x3::IfcSurfaceStyleLighting::DiffuseTransmissionColour() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcColourRgb>(true); }
void Ifc2x3::IfcSurfaceStyleLighting::setDiffuseTransmissionColour(::Ifc2x3::IfcColourRgb* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcColourRgb* Ifc2x3::IfcSurfaceStyleLighting::DiffuseReflectionColour() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcColourRgb>(true); }
void Ifc2x3::IfcSurfaceStyleLighting::setDiffuseReflectionColour(::Ifc2x3::IfcColourRgb* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcColourRgb* Ifc2x3::IfcSurfaceStyleLighting::TransmissionColour() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcColourRgb>(true); }
void Ifc2x3::IfcSurfaceStyleLighting::setTransmissionColour(::Ifc2x3::IfcColourRgb* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcColourRgb* Ifc2x3::IfcSurfaceStyleLighting::ReflectanceColour() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcColourRgb>(true); }
void Ifc2x3::IfcSurfaceStyleLighting::setReflectanceColour(::Ifc2x3::IfcColourRgb* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcSurfaceStyleLighting::declaration() const { return *((IfcParse::entity*)IFC2X3_types[852]); }
const IfcParse::entity& Ifc2x3::IfcSurfaceStyleLighting::Class() { return *((IfcParse::entity*)IFC2X3_types[852]); }
Ifc2x3::IfcSurfaceStyleLighting::IfcSurfaceStyleLighting(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcSurfaceStyleLighting::IfcSurfaceStyleLighting(::Ifc2x3::IfcColourRgb* v1_DiffuseTransmissionColour, ::Ifc2x3::IfcColourRgb* v2_DiffuseReflectionColour, ::Ifc2x3::IfcColourRgb* v3_TransmissionColour, ::Ifc2x3::IfcColourRgb* v4_ReflectanceColour) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_DiffuseTransmissionColour ? v1_DiffuseTransmissionColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_DiffuseReflectionColour ? v2_DiffuseReflectionColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_TransmissionColour ? v3_TransmissionColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_ReflectanceColour ? v4_ReflectanceColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcSurfaceStyleRefraction
boost::optional< double > Ifc2x3::IfcSurfaceStyleRefraction::RefractionIndex() const { if(get_attribute_value(0).isNull()) { return boost::none; } double v = get_attribute_value(0); return v; }
void Ifc2x3::IfcSurfaceStyleRefraction::setRefractionIndex(boost::optional< double > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
boost::optional< double > Ifc2x3::IfcSurfaceStyleRefraction::DispersionFactor() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcSurfaceStyleRefraction::setDispersionFactor(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }


const IfcParse::entity& Ifc2x3::IfcSurfaceStyleRefraction::declaration() const { return *((IfcParse::entity*)IFC2X3_types[853]); }
const IfcParse::entity& Ifc2x3::IfcSurfaceStyleRefraction::Class() { return *((IfcParse::entity*)IFC2X3_types[853]); }
Ifc2x3::IfcSurfaceStyleRefraction::IfcSurfaceStyleRefraction(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcSurfaceStyleRefraction::IfcSurfaceStyleRefraction(boost::optional< double > v1_RefractionIndex, boost::optional< double > v2_DispersionFactor) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) {  if (v1_RefractionIndex) {set_attribute_value(0, (*v1_RefractionIndex)); } if (v2_DispersionFactor) {set_attribute_value(1, (*v2_DispersionFactor)); }; populate_derived(); }

// Function implementations for IfcSurfaceStyleRendering
boost::optional< double > Ifc2x3::IfcSurfaceStyleRendering::Transparency() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcSurfaceStyleRendering::setTransparency(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
::Ifc2x3::IfcColourOrFactor* Ifc2x3::IfcSurfaceStyleRendering::DiffuseColour() const { if(get_attribute_value(2).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcColourOrFactor>(true); }
void Ifc2x3::IfcSurfaceStyleRendering::setDiffuseColour(::Ifc2x3::IfcColourOrFactor* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcColourOrFactor* Ifc2x3::IfcSurfaceStyleRendering::TransmissionColour() const { if(get_attribute_value(3).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcColourOrFactor>(true); }
void Ifc2x3::IfcSurfaceStyleRendering::setTransmissionColour(::Ifc2x3::IfcColourOrFactor* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }
::Ifc2x3::IfcColourOrFactor* Ifc2x3::IfcSurfaceStyleRendering::DiffuseTransmissionColour() const { if(get_attribute_value(4).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcColourOrFactor>(true); }
void Ifc2x3::IfcSurfaceStyleRendering::setDiffuseTransmissionColour(::Ifc2x3::IfcColourOrFactor* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcColourOrFactor* Ifc2x3::IfcSurfaceStyleRendering::ReflectionColour() const { if(get_attribute_value(5).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcColourOrFactor>(true); }
void Ifc2x3::IfcSurfaceStyleRendering::setReflectionColour(::Ifc2x3::IfcColourOrFactor* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcColourOrFactor* Ifc2x3::IfcSurfaceStyleRendering::SpecularColour() const { if(get_attribute_value(6).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcColourOrFactor>(true); }
void Ifc2x3::IfcSurfaceStyleRendering::setSpecularColour(::Ifc2x3::IfcColourOrFactor* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
::Ifc2x3::IfcSpecularHighlightSelect* Ifc2x3::IfcSurfaceStyleRendering::SpecularHighlight() const { if(get_attribute_value(7).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(7)))->as<::Ifc2x3::IfcSpecularHighlightSelect>(true); }
void Ifc2x3::IfcSurfaceStyleRendering::setSpecularHighlight(::Ifc2x3::IfcSpecularHighlightSelect* v) { set_attribute_value(7, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(7); }
::Ifc2x3::IfcReflectanceMethodEnum::Value Ifc2x3::IfcSurfaceStyleRendering::ReflectanceMethod() const {  return ::Ifc2x3::IfcReflectanceMethodEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcSurfaceStyleRendering::setReflectanceMethod(::Ifc2x3::IfcReflectanceMethodEnum::Value v) { set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcReflectanceMethodEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }


const IfcParse::entity& Ifc2x3::IfcSurfaceStyleRendering::declaration() const { return *((IfcParse::entity*)IFC2X3_types[854]); }
const IfcParse::entity& Ifc2x3::IfcSurfaceStyleRendering::Class() { return *((IfcParse::entity*)IFC2X3_types[854]); }
Ifc2x3::IfcSurfaceStyleRendering::IfcSurfaceStyleRendering(IfcEntityInstanceData&& e) : IfcSurfaceStyleShading(std::move(e)) { }
Ifc2x3::IfcSurfaceStyleRendering::IfcSurfaceStyleRendering(::Ifc2x3::IfcColourRgb* v1_SurfaceColour, boost::optional< double > v2_Transparency, ::Ifc2x3::IfcColourOrFactor* v3_DiffuseColour, ::Ifc2x3::IfcColourOrFactor* v4_TransmissionColour, ::Ifc2x3::IfcColourOrFactor* v5_DiffuseTransmissionColour, ::Ifc2x3::IfcColourOrFactor* v6_ReflectionColour, ::Ifc2x3::IfcColourOrFactor* v7_SpecularColour, ::Ifc2x3::IfcSpecularHighlightSelect* v8_SpecularHighlight, ::Ifc2x3::IfcReflectanceMethodEnum::Value v9_ReflectanceMethod) : IfcSurfaceStyleShading(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, v1_SurfaceColour ? v1_SurfaceColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_Transparency) {set_attribute_value(1, (*v2_Transparency)); }set_attribute_value(2, v3_DiffuseColour ? v3_DiffuseColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_TransmissionColour ? v4_TransmissionColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(4, v5_DiffuseTransmissionColour ? v5_DiffuseTransmissionColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(5, v6_ReflectionColour ? v6_ReflectionColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_SpecularColour ? v7_SpecularColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(7, v8_SpecularHighlight ? v8_SpecularHighlight->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcReflectanceMethodEnum::Class(),(size_t)v9_ReflectanceMethod)));; populate_derived(); }

// Function implementations for IfcSurfaceStyleShading
::Ifc2x3::IfcColourRgb* Ifc2x3::IfcSurfaceStyleShading::SurfaceColour() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcColourRgb>(true); }
void Ifc2x3::IfcSurfaceStyleShading::setSurfaceColour(::Ifc2x3::IfcColourRgb* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcSurfaceStyleShading::declaration() const { return *((IfcParse::entity*)IFC2X3_types[855]); }
const IfcParse::entity& Ifc2x3::IfcSurfaceStyleShading::Class() { return *((IfcParse::entity*)IFC2X3_types[855]); }
Ifc2x3::IfcSurfaceStyleShading::IfcSurfaceStyleShading(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcSurfaceStyleShading::IfcSurfaceStyleShading(::Ifc2x3::IfcColourRgb* v1_SurfaceColour) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, v1_SurfaceColour ? v1_SurfaceColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcSurfaceStyleWithTextures
aggregate_of< ::Ifc2x3::IfcSurfaceTexture >::ptr Ifc2x3::IfcSurfaceStyleWithTextures::Textures() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcSurfaceTexture >(); }
void Ifc2x3::IfcSurfaceStyleWithTextures::setTextures(aggregate_of< ::Ifc2x3::IfcSurfaceTexture >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcSurfaceStyleWithTextures::declaration() const { return *((IfcParse::entity*)IFC2X3_types[856]); }
const IfcParse::entity& Ifc2x3::IfcSurfaceStyleWithTextures::Class() { return *((IfcParse::entity*)IFC2X3_types[856]); }
Ifc2x3::IfcSurfaceStyleWithTextures::IfcSurfaceStyleWithTextures(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcSurfaceStyleWithTextures::IfcSurfaceStyleWithTextures(aggregate_of< ::Ifc2x3::IfcSurfaceTexture >::ptr v1_Textures) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Textures)->generalize());; populate_derived(); }

// Function implementations for IfcSurfaceTexture
bool Ifc2x3::IfcSurfaceTexture::RepeatS() const {  bool v = get_attribute_value(0); return v; }
void Ifc2x3::IfcSurfaceTexture::setRepeatS(bool v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
bool Ifc2x3::IfcSurfaceTexture::RepeatT() const {  bool v = get_attribute_value(1); return v; }
void Ifc2x3::IfcSurfaceTexture::setRepeatT(bool v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcSurfaceTextureEnum::Value Ifc2x3::IfcSurfaceTexture::TextureType() const {  return ::Ifc2x3::IfcSurfaceTextureEnum::FromString(get_attribute_value(2)); }
void Ifc2x3::IfcSurfaceTexture::setTextureType(::Ifc2x3::IfcSurfaceTextureEnum::Value v) { set_attribute_value(2, EnumerationReference(&::Ifc2x3::IfcSurfaceTextureEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcCartesianTransformationOperator2D* Ifc2x3::IfcSurfaceTexture::TextureTransform() const { if(get_attribute_value(3).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcCartesianTransformationOperator2D>(true); }
void Ifc2x3::IfcSurfaceTexture::setTextureTransform(::Ifc2x3::IfcCartesianTransformationOperator2D* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcSurfaceTexture::declaration() const { return *((IfcParse::entity*)IFC2X3_types[857]); }
const IfcParse::entity& Ifc2x3::IfcSurfaceTexture::Class() { return *((IfcParse::entity*)IFC2X3_types[857]); }
Ifc2x3::IfcSurfaceTexture::IfcSurfaceTexture(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcSurfaceTexture::IfcSurfaceTexture(bool v1_RepeatS, bool v2_RepeatT, ::Ifc2x3::IfcSurfaceTextureEnum::Value v3_TextureType, ::Ifc2x3::IfcCartesianTransformationOperator2D* v4_TextureTransform) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, (v1_RepeatS));set_attribute_value(1, (v2_RepeatT));set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcSurfaceTextureEnum::Class(),(size_t)v3_TextureType)));set_attribute_value(3, v4_TextureTransform ? v4_TextureTransform->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcSweptAreaSolid
::Ifc2x3::IfcProfileDef* Ifc2x3::IfcSweptAreaSolid::SweptArea() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcProfileDef>(true); }
void Ifc2x3::IfcSweptAreaSolid::setSweptArea(::Ifc2x3::IfcProfileDef* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcAxis2Placement3D* Ifc2x3::IfcSweptAreaSolid::Position() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcAxis2Placement3D>(true); }
void Ifc2x3::IfcSweptAreaSolid::setPosition(::Ifc2x3::IfcAxis2Placement3D* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcSweptAreaSolid::declaration() const { return *((IfcParse::entity*)IFC2X3_types[859]); }
const IfcParse::entity& Ifc2x3::IfcSweptAreaSolid::Class() { return *((IfcParse::entity*)IFC2X3_types[859]); }
Ifc2x3::IfcSweptAreaSolid::IfcSweptAreaSolid(IfcEntityInstanceData&& e) : IfcSolidModel(std::move(e)) { }
Ifc2x3::IfcSweptAreaSolid::IfcSweptAreaSolid(::Ifc2x3::IfcProfileDef* v1_SweptArea, ::Ifc2x3::IfcAxis2Placement3D* v2_Position) : IfcSolidModel(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_SweptArea ? v1_SweptArea->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_Position ? v2_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcSweptDiskSolid
::Ifc2x3::IfcCurve* Ifc2x3::IfcSweptDiskSolid::Directrix() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcCurve>(true); }
void Ifc2x3::IfcSweptDiskSolid::setDirectrix(::Ifc2x3::IfcCurve* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
double Ifc2x3::IfcSweptDiskSolid::Radius() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcSweptDiskSolid::setRadius(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
boost::optional< double > Ifc2x3::IfcSweptDiskSolid::InnerRadius() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcSweptDiskSolid::setInnerRadius(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
double Ifc2x3::IfcSweptDiskSolid::StartParam() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcSweptDiskSolid::setStartParam(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
double Ifc2x3::IfcSweptDiskSolid::EndParam() const {  double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcSweptDiskSolid::setEndParam(double v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcSweptDiskSolid::declaration() const { return *((IfcParse::entity*)IFC2X3_types[860]); }
const IfcParse::entity& Ifc2x3::IfcSweptDiskSolid::Class() { return *((IfcParse::entity*)IFC2X3_types[860]); }
Ifc2x3::IfcSweptDiskSolid::IfcSweptDiskSolid(IfcEntityInstanceData&& e) : IfcSolidModel(std::move(e)) { }
Ifc2x3::IfcSweptDiskSolid::IfcSweptDiskSolid(::Ifc2x3::IfcCurve* v1_Directrix, double v2_Radius, boost::optional< double > v3_InnerRadius, double v4_StartParam, double v5_EndParam) : IfcSolidModel(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, v1_Directrix ? v1_Directrix->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Radius)); if (v3_InnerRadius) {set_attribute_value(2, (*v3_InnerRadius)); }set_attribute_value(3, (v4_StartParam));set_attribute_value(4, (v5_EndParam));; populate_derived(); }

// Function implementations for IfcSweptSurface
::Ifc2x3::IfcProfileDef* Ifc2x3::IfcSweptSurface::SweptCurve() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcProfileDef>(true); }
void Ifc2x3::IfcSweptSurface::setSweptCurve(::Ifc2x3::IfcProfileDef* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcAxis2Placement3D* Ifc2x3::IfcSweptSurface::Position() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcAxis2Placement3D>(true); }
void Ifc2x3::IfcSweptSurface::setPosition(::Ifc2x3::IfcAxis2Placement3D* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcSweptSurface::declaration() const { return *((IfcParse::entity*)IFC2X3_types[861]); }
const IfcParse::entity& Ifc2x3::IfcSweptSurface::Class() { return *((IfcParse::entity*)IFC2X3_types[861]); }
Ifc2x3::IfcSweptSurface::IfcSweptSurface(IfcEntityInstanceData&& e) : IfcSurface(std::move(e)) { }
Ifc2x3::IfcSweptSurface::IfcSweptSurface(::Ifc2x3::IfcProfileDef* v1_SweptCurve, ::Ifc2x3::IfcAxis2Placement3D* v2_Position) : IfcSurface(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_SweptCurve ? v1_SweptCurve->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_Position ? v2_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcSwitchingDeviceType
::Ifc2x3::IfcSwitchingDeviceTypeEnum::Value Ifc2x3::IfcSwitchingDeviceType::PredefinedType() const {  return ::Ifc2x3::IfcSwitchingDeviceTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcSwitchingDeviceType::setPredefinedType(::Ifc2x3::IfcSwitchingDeviceTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcSwitchingDeviceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcSwitchingDeviceType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[862]); }
const IfcParse::entity& Ifc2x3::IfcSwitchingDeviceType::Class() { return *((IfcParse::entity*)IFC2X3_types[862]); }
Ifc2x3::IfcSwitchingDeviceType::IfcSwitchingDeviceType(IfcEntityInstanceData&& e) : IfcFlowControllerType(std::move(e)) { }
Ifc2x3::IfcSwitchingDeviceType::IfcSwitchingDeviceType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcSwitchingDeviceTypeEnum::Value v10_PredefinedType) : IfcFlowControllerType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcSwitchingDeviceTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcSymbolStyle
::Ifc2x3::IfcSymbolStyleSelect* Ifc2x3::IfcSymbolStyle::StyleOfSymbol() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcSymbolStyleSelect>(true); }
void Ifc2x3::IfcSymbolStyle::setStyleOfSymbol(::Ifc2x3::IfcSymbolStyleSelect* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcSymbolStyle::declaration() const { return *((IfcParse::entity*)IFC2X3_types[864]); }
const IfcParse::entity& Ifc2x3::IfcSymbolStyle::Class() { return *((IfcParse::entity*)IFC2X3_types[864]); }
Ifc2x3::IfcSymbolStyle::IfcSymbolStyle(IfcEntityInstanceData&& e) : IfcPresentationStyle(std::move(e)) { }
Ifc2x3::IfcSymbolStyle::IfcSymbolStyle(boost::optional< std::string > v1_Name, ::Ifc2x3::IfcSymbolStyleSelect* v2_StyleOfSymbol) : IfcPresentationStyle(IfcEntityInstanceData(in_memory_attribute_storage(2))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, v2_StyleOfSymbol ? v2_StyleOfSymbol->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcSystem

::Ifc2x3::IfcRelServicesBuildings::list::ptr Ifc2x3::IfcSystem::ServicesBuildings() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[715], 4)->as<IfcRelServicesBuildings>(); }

const IfcParse::entity& Ifc2x3::IfcSystem::declaration() const { return *((IfcParse::entity*)IFC2X3_types[866]); }
const IfcParse::entity& Ifc2x3::IfcSystem::Class() { return *((IfcParse::entity*)IFC2X3_types[866]); }
Ifc2x3::IfcSystem::IfcSystem(IfcEntityInstanceData&& e) : IfcGroup(std::move(e)) { }
Ifc2x3::IfcSystem::IfcSystem(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcGroup(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }; populate_derived(); }

// Function implementations for IfcSystemFurnitureElementType


const IfcParse::entity& Ifc2x3::IfcSystemFurnitureElementType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[867]); }
const IfcParse::entity& Ifc2x3::IfcSystemFurnitureElementType::Class() { return *((IfcParse::entity*)IFC2X3_types[867]); }
Ifc2x3::IfcSystemFurnitureElementType::IfcSystemFurnitureElementType(IfcEntityInstanceData&& e) : IfcFurnishingElementType(std::move(e)) { }
Ifc2x3::IfcSystemFurnitureElementType::IfcSystemFurnitureElementType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType) : IfcFurnishingElementType(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }; populate_derived(); }

// Function implementations for IfcTShapeProfileDef
double Ifc2x3::IfcTShapeProfileDef::Depth() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcTShapeProfileDef::setDepth(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
double Ifc2x3::IfcTShapeProfileDef::FlangeWidth() const {  double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcTShapeProfileDef::setFlangeWidth(double v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
double Ifc2x3::IfcTShapeProfileDef::WebThickness() const {  double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcTShapeProfileDef::setWebThickness(double v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
double Ifc2x3::IfcTShapeProfileDef::FlangeThickness() const {  double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcTShapeProfileDef::setFlangeThickness(double v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
boost::optional< double > Ifc2x3::IfcTShapeProfileDef::FilletRadius() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcTShapeProfileDef::setFilletRadius(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
boost::optional< double > Ifc2x3::IfcTShapeProfileDef::FlangeEdgeRadius() const { if(get_attribute_value(8).isNull()) { return boost::none; } double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcTShapeProfileDef::setFlangeEdgeRadius(boost::optional< double > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
boost::optional< double > Ifc2x3::IfcTShapeProfileDef::WebEdgeRadius() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcTShapeProfileDef::setWebEdgeRadius(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
boost::optional< double > Ifc2x3::IfcTShapeProfileDef::WebSlope() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcTShapeProfileDef::setWebSlope(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
boost::optional< double > Ifc2x3::IfcTShapeProfileDef::FlangeSlope() const { if(get_attribute_value(11).isNull()) { return boost::none; } double v = get_attribute_value(11); return v; }
void Ifc2x3::IfcTShapeProfileDef::setFlangeSlope(boost::optional< double > v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
boost::optional< double > Ifc2x3::IfcTShapeProfileDef::CentreOfGravityInY() const { if(get_attribute_value(12).isNull()) { return boost::none; } double v = get_attribute_value(12); return v; }
void Ifc2x3::IfcTShapeProfileDef::setCentreOfGravityInY(boost::optional< double > v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }


const IfcParse::entity& Ifc2x3::IfcTShapeProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[928]); }
const IfcParse::entity& Ifc2x3::IfcTShapeProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[928]); }
Ifc2x3::IfcTShapeProfileDef::IfcTShapeProfileDef(IfcEntityInstanceData&& e) : IfcParameterizedProfileDef(std::move(e)) { }
Ifc2x3::IfcTShapeProfileDef::IfcTShapeProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcAxis2Placement2D* v3_Position, double v4_Depth, double v5_FlangeWidth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius, boost::optional< double > v9_FlangeEdgeRadius, boost::optional< double > v10_WebEdgeRadius, boost::optional< double > v11_WebSlope, boost::optional< double > v12_FlangeSlope, boost::optional< double > v13_CentreOfGravityInY) : IfcParameterizedProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(13))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_Depth));set_attribute_value(4, (v5_FlangeWidth));set_attribute_value(5, (v6_WebThickness));set_attribute_value(6, (v7_FlangeThickness)); if (v8_FilletRadius) {set_attribute_value(7, (*v8_FilletRadius)); } if (v9_FlangeEdgeRadius) {set_attribute_value(8, (*v9_FlangeEdgeRadius)); } if (v10_WebEdgeRadius) {set_attribute_value(9, (*v10_WebEdgeRadius)); } if (v11_WebSlope) {set_attribute_value(10, (*v11_WebSlope)); } if (v12_FlangeSlope) {set_attribute_value(11, (*v12_FlangeSlope)); } if (v13_CentreOfGravityInY) {set_attribute_value(12, (*v13_CentreOfGravityInY)); }; populate_derived(); }

// Function implementations for IfcTable
std::string Ifc2x3::IfcTable::Name() const {  std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcTable::setName(std::string v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcTableRow >::ptr Ifc2x3::IfcTable::Rows() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcTableRow >(); }
void Ifc2x3::IfcTable::setRows(aggregate_of< ::Ifc2x3::IfcTableRow >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcTable::declaration() const { return *((IfcParse::entity*)IFC2X3_types[868]); }
const IfcParse::entity& Ifc2x3::IfcTable::Class() { return *((IfcParse::entity*)IFC2X3_types[868]); }
Ifc2x3::IfcTable::IfcTable(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcTable::IfcTable(std::string v1_Name, aggregate_of< ::Ifc2x3::IfcTableRow >::ptr v2_Rows) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (v1_Name));set_attribute_value(1, (v2_Rows)->generalize());; populate_derived(); }

// Function implementations for IfcTableRow
aggregate_of< ::Ifc2x3::IfcValue >::ptr Ifc2x3::IfcTableRow::RowCells() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcValue >(); }
void Ifc2x3::IfcTableRow::setRowCells(aggregate_of< ::Ifc2x3::IfcValue >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }
bool Ifc2x3::IfcTableRow::IsHeading() const {  bool v = get_attribute_value(1); return v; }
void Ifc2x3::IfcTableRow::setIsHeading(bool v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }

::Ifc2x3::IfcTable::list::ptr Ifc2x3::IfcTableRow::OfTable() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[868], 1)->as<IfcTable>(); }

const IfcParse::entity& Ifc2x3::IfcTableRow::declaration() const { return *((IfcParse::entity*)IFC2X3_types[869]); }
const IfcParse::entity& Ifc2x3::IfcTableRow::Class() { return *((IfcParse::entity*)IFC2X3_types[869]); }
Ifc2x3::IfcTableRow::IfcTableRow(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcTableRow::IfcTableRow(aggregate_of< ::Ifc2x3::IfcValue >::ptr v1_RowCells, bool v2_IsHeading) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (v1_RowCells)->generalize());set_attribute_value(1, (v2_IsHeading));; populate_derived(); }

// Function implementations for IfcTankType
::Ifc2x3::IfcTankTypeEnum::Value Ifc2x3::IfcTankType::PredefinedType() const {  return ::Ifc2x3::IfcTankTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcTankType::setPredefinedType(::Ifc2x3::IfcTankTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcTankTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcTankType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[870]); }
const IfcParse::entity& Ifc2x3::IfcTankType::Class() { return *((IfcParse::entity*)IFC2X3_types[870]); }
Ifc2x3::IfcTankType::IfcTankType(IfcEntityInstanceData&& e) : IfcFlowStorageDeviceType(std::move(e)) { }
Ifc2x3::IfcTankType::IfcTankType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcTankTypeEnum::Value v10_PredefinedType) : IfcFlowStorageDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcTankTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcTask
std::string Ifc2x3::IfcTask::TaskId() const {  std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcTask::setTaskId(std::string v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
boost::optional< std::string > Ifc2x3::IfcTask::Status() const { if(get_attribute_value(6).isNull()) { return boost::none; } std::string v = get_attribute_value(6); return v; }
void Ifc2x3::IfcTask::setStatus(boost::optional< std::string > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
boost::optional< std::string > Ifc2x3::IfcTask::WorkMethod() const { if(get_attribute_value(7).isNull()) { return boost::none; } std::string v = get_attribute_value(7); return v; }
void Ifc2x3::IfcTask::setWorkMethod(boost::optional< std::string > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
bool Ifc2x3::IfcTask::IsMilestone() const {  bool v = get_attribute_value(8); return v; }
void Ifc2x3::IfcTask::setIsMilestone(bool v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
boost::optional< int > Ifc2x3::IfcTask::Priority() const { if(get_attribute_value(9).isNull()) { return boost::none; } int v = get_attribute_value(9); return v; }
void Ifc2x3::IfcTask::setPriority(boost::optional< int > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }


const IfcParse::entity& Ifc2x3::IfcTask::declaration() const { return *((IfcParse::entity*)IFC2X3_types[872]); }
const IfcParse::entity& Ifc2x3::IfcTask::Class() { return *((IfcParse::entity*)IFC2X3_types[872]); }
Ifc2x3::IfcTask::IfcTask(IfcEntityInstanceData&& e) : IfcProcess(std::move(e)) { }
Ifc2x3::IfcTask::IfcTask(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_TaskId, boost::optional< std::string > v7_Status, boost::optional< std::string > v8_WorkMethod, bool v9_IsMilestone, boost::optional< int > v10_Priority) : IfcProcess(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (v6_TaskId)); if (v7_Status) {set_attribute_value(6, (*v7_Status)); } if (v8_WorkMethod) {set_attribute_value(7, (*v8_WorkMethod)); }set_attribute_value(8, (v9_IsMilestone)); if (v10_Priority) {set_attribute_value(9, (*v10_Priority)); }; populate_derived(); }

// Function implementations for IfcTelecomAddress
boost::optional< std::vector< std::string > /*[1:?]*/ > Ifc2x3::IfcTelecomAddress::TelephoneNumbers() const { if(get_attribute_value(3).isNull()) { return boost::none; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(3); return v; }
void Ifc2x3::IfcTelecomAddress::setTelephoneNumbers(boost::optional< std::vector< std::string > /*[1:?]*/ > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< std::vector< std::string > /*[1:?]*/ > Ifc2x3::IfcTelecomAddress::FacsimileNumbers() const { if(get_attribute_value(4).isNull()) { return boost::none; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(4); return v; }
void Ifc2x3::IfcTelecomAddress::setFacsimileNumbers(boost::optional< std::vector< std::string > /*[1:?]*/ > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< std::string > Ifc2x3::IfcTelecomAddress::PagerNumber() const { if(get_attribute_value(5).isNull()) { return boost::none; } std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcTelecomAddress::setPagerNumber(boost::optional< std::string > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< std::vector< std::string > /*[1:?]*/ > Ifc2x3::IfcTelecomAddress::ElectronicMailAddresses() const { if(get_attribute_value(6).isNull()) { return boost::none; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(6); return v; }
void Ifc2x3::IfcTelecomAddress::setElectronicMailAddresses(boost::optional< std::vector< std::string > /*[1:?]*/ > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
boost::optional< std::string > Ifc2x3::IfcTelecomAddress::WWWHomePageURL() const { if(get_attribute_value(7).isNull()) { return boost::none; } std::string v = get_attribute_value(7); return v; }
void Ifc2x3::IfcTelecomAddress::setWWWHomePageURL(boost::optional< std::string > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }


const IfcParse::entity& Ifc2x3::IfcTelecomAddress::declaration() const { return *((IfcParse::entity*)IFC2X3_types[873]); }
const IfcParse::entity& Ifc2x3::IfcTelecomAddress::Class() { return *((IfcParse::entity*)IFC2X3_types[873]); }
Ifc2x3::IfcTelecomAddress::IfcTelecomAddress(IfcEntityInstanceData&& e) : IfcAddress(std::move(e)) { }
Ifc2x3::IfcTelecomAddress::IfcTelecomAddress(boost::optional< ::Ifc2x3::IfcAddressTypeEnum::Value > v1_Purpose, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_UserDefinedPurpose, boost::optional< std::vector< std::string > /*[1:?]*/ > v4_TelephoneNumbers, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_FacsimileNumbers, boost::optional< std::string > v6_PagerNumber, boost::optional< std::vector< std::string > /*[1:?]*/ > v7_ElectronicMailAddresses, boost::optional< std::string > v8_WWWHomePageURL) : IfcAddress(IfcEntityInstanceData(in_memory_attribute_storage(8))) {  if (v1_Purpose) {set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcAddressTypeEnum::Class(),(size_t)*v1_Purpose))); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); } if (v3_UserDefinedPurpose) {set_attribute_value(2, (*v3_UserDefinedPurpose)); } if (v4_TelephoneNumbers) {set_attribute_value(3, (*v4_TelephoneNumbers)); } if (v5_FacsimileNumbers) {set_attribute_value(4, (*v5_FacsimileNumbers)); } if (v6_PagerNumber) {set_attribute_value(5, (*v6_PagerNumber)); } if (v7_ElectronicMailAddresses) {set_attribute_value(6, (*v7_ElectronicMailAddresses)); } if (v8_WWWHomePageURL) {set_attribute_value(7, (*v8_WWWHomePageURL)); }; populate_derived(); }

// Function implementations for IfcTendon
::Ifc2x3::IfcTendonTypeEnum::Value Ifc2x3::IfcTendon::PredefinedType() const {  return ::Ifc2x3::IfcTendonTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcTendon::setPredefinedType(::Ifc2x3::IfcTendonTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcTendonTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
double Ifc2x3::IfcTendon::NominalDiameter() const {  double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcTendon::setNominalDiameter(double v) { set_attribute_value(10, v);if constexpr (false)unset_attribute_value(10); }
double Ifc2x3::IfcTendon::CrossSectionArea() const {  double v = get_attribute_value(11); return v; }
void Ifc2x3::IfcTendon::setCrossSectionArea(double v) { set_attribute_value(11, v);if constexpr (false)unset_attribute_value(11); }
boost::optional< double > Ifc2x3::IfcTendon::TensionForce() const { if(get_attribute_value(12).isNull()) { return boost::none; } double v = get_attribute_value(12); return v; }
void Ifc2x3::IfcTendon::setTensionForce(boost::optional< double > v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
boost::optional< double > Ifc2x3::IfcTendon::PreStress() const { if(get_attribute_value(13).isNull()) { return boost::none; } double v = get_attribute_value(13); return v; }
void Ifc2x3::IfcTendon::setPreStress(boost::optional< double > v) { if (v) {set_attribute_value(13, *v);} else {unset_attribute_value(13);} }
boost::optional< double > Ifc2x3::IfcTendon::FrictionCoefficient() const { if(get_attribute_value(14).isNull()) { return boost::none; } double v = get_attribute_value(14); return v; }
void Ifc2x3::IfcTendon::setFrictionCoefficient(boost::optional< double > v) { if (v) {set_attribute_value(14, *v);} else {unset_attribute_value(14);} }
boost::optional< double > Ifc2x3::IfcTendon::AnchorageSlip() const { if(get_attribute_value(15).isNull()) { return boost::none; } double v = get_attribute_value(15); return v; }
void Ifc2x3::IfcTendon::setAnchorageSlip(boost::optional< double > v) { if (v) {set_attribute_value(15, *v);} else {unset_attribute_value(15);} }
boost::optional< double > Ifc2x3::IfcTendon::MinCurvatureRadius() const { if(get_attribute_value(16).isNull()) { return boost::none; } double v = get_attribute_value(16); return v; }
void Ifc2x3::IfcTendon::setMinCurvatureRadius(boost::optional< double > v) { if (v) {set_attribute_value(16, *v);} else {unset_attribute_value(16);} }


const IfcParse::entity& Ifc2x3::IfcTendon::declaration() const { return *((IfcParse::entity*)IFC2X3_types[875]); }
const IfcParse::entity& Ifc2x3::IfcTendon::Class() { return *((IfcParse::entity*)IFC2X3_types[875]); }
Ifc2x3::IfcTendon::IfcTendon(IfcEntityInstanceData&& e) : IfcReinforcingElement(std::move(e)) { }
Ifc2x3::IfcTendon::IfcTendon(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade, ::Ifc2x3::IfcTendonTypeEnum::Value v10_PredefinedType, double v11_NominalDiameter, double v12_CrossSectionArea, boost::optional< double > v13_TensionForce, boost::optional< double > v14_PreStress, boost::optional< double > v15_FrictionCoefficient, boost::optional< double > v16_AnchorageSlip, boost::optional< double > v17_MinCurvatureRadius) : IfcReinforcingElement(IfcEntityInstanceData(in_memory_attribute_storage(17))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_SteelGrade) {set_attribute_value(8, (*v9_SteelGrade)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcTendonTypeEnum::Class(),(size_t)v10_PredefinedType)));set_attribute_value(10, (v11_NominalDiameter));set_attribute_value(11, (v12_CrossSectionArea)); if (v13_TensionForce) {set_attribute_value(12, (*v13_TensionForce)); } if (v14_PreStress) {set_attribute_value(13, (*v14_PreStress)); } if (v15_FrictionCoefficient) {set_attribute_value(14, (*v15_FrictionCoefficient)); } if (v16_AnchorageSlip) {set_attribute_value(15, (*v16_AnchorageSlip)); } if (v17_MinCurvatureRadius) {set_attribute_value(16, (*v17_MinCurvatureRadius)); }; populate_derived(); }

// Function implementations for IfcTendonAnchor


const IfcParse::entity& Ifc2x3::IfcTendonAnchor::declaration() const { return *((IfcParse::entity*)IFC2X3_types[876]); }
const IfcParse::entity& Ifc2x3::IfcTendonAnchor::Class() { return *((IfcParse::entity*)IFC2X3_types[876]); }
Ifc2x3::IfcTendonAnchor::IfcTendonAnchor(IfcEntityInstanceData&& e) : IfcReinforcingElement(std::move(e)) { }
Ifc2x3::IfcTendonAnchor::IfcTendonAnchor(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_SteelGrade) : IfcReinforcingElement(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_SteelGrade) {set_attribute_value(8, (*v9_SteelGrade)); }; populate_derived(); }

// Function implementations for IfcTerminatorSymbol
::Ifc2x3::IfcAnnotationCurveOccurrence* Ifc2x3::IfcTerminatorSymbol::AnnotatedCurve() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcAnnotationCurveOccurrence>(true); }
void Ifc2x3::IfcTerminatorSymbol::setAnnotatedCurve(::Ifc2x3::IfcAnnotationCurveOccurrence* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcTerminatorSymbol::declaration() const { return *((IfcParse::entity*)IFC2X3_types[878]); }
const IfcParse::entity& Ifc2x3::IfcTerminatorSymbol::Class() { return *((IfcParse::entity*)IFC2X3_types[878]); }
Ifc2x3::IfcTerminatorSymbol::IfcTerminatorSymbol(IfcEntityInstanceData&& e) : IfcAnnotationSymbolOccurrence(std::move(e)) { }
Ifc2x3::IfcTerminatorSymbol::IfcTerminatorSymbol(::Ifc2x3::IfcRepresentationItem* v1_Item, aggregate_of< ::Ifc2x3::IfcPresentationStyleAssignment >::ptr v2_Styles, boost::optional< std::string > v3_Name, ::Ifc2x3::IfcAnnotationCurveOccurrence* v4_AnnotatedCurve) : IfcAnnotationSymbolOccurrence(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_Item ? v1_Item->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Styles)->generalize()); if (v3_Name) {set_attribute_value(2, (*v3_Name)); }set_attribute_value(3, v4_AnnotatedCurve ? v4_AnnotatedCurve->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcTextLiteral
std::string Ifc2x3::IfcTextLiteral::Literal() const {  std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcTextLiteral::setLiteral(std::string v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcAxis2Placement* Ifc2x3::IfcTextLiteral::Placement() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcAxis2Placement>(true); }
void Ifc2x3::IfcTextLiteral::setPlacement(::Ifc2x3::IfcAxis2Placement* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcTextPath::Value Ifc2x3::IfcTextLiteral::Path() const {  return ::Ifc2x3::IfcTextPath::FromString(get_attribute_value(2)); }
void Ifc2x3::IfcTextLiteral::setPath(::Ifc2x3::IfcTextPath::Value v) { set_attribute_value(2, EnumerationReference(&::Ifc2x3::IfcTextPath::Class(), (size_t) v));if constexpr (false)unset_attribute_value(2); }


const IfcParse::entity& Ifc2x3::IfcTextLiteral::declaration() const { return *((IfcParse::entity*)IFC2X3_types[884]); }
const IfcParse::entity& Ifc2x3::IfcTextLiteral::Class() { return *((IfcParse::entity*)IFC2X3_types[884]); }
Ifc2x3::IfcTextLiteral::IfcTextLiteral(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcTextLiteral::IfcTextLiteral(std::string v1_Literal, ::Ifc2x3::IfcAxis2Placement* v2_Placement, ::Ifc2x3::IfcTextPath::Value v3_Path) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(3))) { set_attribute_value(0, (v1_Literal));set_attribute_value(1, v2_Placement ? v2_Placement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcTextPath::Class(),(size_t)v3_Path)));; populate_derived(); }

// Function implementations for IfcTextLiteralWithExtent
::Ifc2x3::IfcPlanarExtent* Ifc2x3::IfcTextLiteralWithExtent::Extent() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcPlanarExtent>(true); }
void Ifc2x3::IfcTextLiteralWithExtent::setExtent(::Ifc2x3::IfcPlanarExtent* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }
std::string Ifc2x3::IfcTextLiteralWithExtent::BoxAlignment() const {  std::string v = get_attribute_value(4); return v; }
void Ifc2x3::IfcTextLiteralWithExtent::setBoxAlignment(std::string v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcTextLiteralWithExtent::declaration() const { return *((IfcParse::entity*)IFC2X3_types[885]); }
const IfcParse::entity& Ifc2x3::IfcTextLiteralWithExtent::Class() { return *((IfcParse::entity*)IFC2X3_types[885]); }
Ifc2x3::IfcTextLiteralWithExtent::IfcTextLiteralWithExtent(IfcEntityInstanceData&& e) : IfcTextLiteral(std::move(e)) { }
Ifc2x3::IfcTextLiteralWithExtent::IfcTextLiteralWithExtent(std::string v1_Literal, ::Ifc2x3::IfcAxis2Placement* v2_Placement, ::Ifc2x3::IfcTextPath::Value v3_Path, ::Ifc2x3::IfcPlanarExtent* v4_Extent, std::string v5_BoxAlignment) : IfcTextLiteral(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_Literal));set_attribute_value(1, v2_Placement ? v2_Placement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, (EnumerationReference(&::Ifc2x3::IfcTextPath::Class(),(size_t)v3_Path)));set_attribute_value(3, v4_Extent ? v4_Extent->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(4, (v5_BoxAlignment));; populate_derived(); }

// Function implementations for IfcTextStyle
::Ifc2x3::IfcCharacterStyleSelect* Ifc2x3::IfcTextStyle::TextCharacterAppearance() const { if(get_attribute_value(1).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcCharacterStyleSelect>(true); }
void Ifc2x3::IfcTextStyle::setTextCharacterAppearance(::Ifc2x3::IfcCharacterStyleSelect* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }
::Ifc2x3::IfcTextStyleSelect* Ifc2x3::IfcTextStyle::TextStyle() const { if(get_attribute_value(2).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcTextStyleSelect>(true); }
void Ifc2x3::IfcTextStyle::setTextStyle(::Ifc2x3::IfcTextStyleSelect* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcTextFontSelect* Ifc2x3::IfcTextStyle::TextFontStyle() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcTextFontSelect>(true); }
void Ifc2x3::IfcTextStyle::setTextFontStyle(::Ifc2x3::IfcTextFontSelect* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }


const IfcParse::entity& Ifc2x3::IfcTextStyle::declaration() const { return *((IfcParse::entity*)IFC2X3_types[887]); }
const IfcParse::entity& Ifc2x3::IfcTextStyle::Class() { return *((IfcParse::entity*)IFC2X3_types[887]); }
Ifc2x3::IfcTextStyle::IfcTextStyle(IfcEntityInstanceData&& e) : IfcPresentationStyle(std::move(e)) { }
Ifc2x3::IfcTextStyle::IfcTextStyle(boost::optional< std::string > v1_Name, ::Ifc2x3::IfcCharacterStyleSelect* v2_TextCharacterAppearance, ::Ifc2x3::IfcTextStyleSelect* v3_TextStyle, ::Ifc2x3::IfcTextFontSelect* v4_TextFontStyle) : IfcPresentationStyle(IfcEntityInstanceData(in_memory_attribute_storage(4))) {  if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, v2_TextCharacterAppearance ? v2_TextCharacterAppearance->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(2, v3_TextStyle ? v3_TextStyle->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_TextFontStyle ? v4_TextFontStyle->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcTextStyleFontModel
boost::optional< std::vector< std::string > /*[1:?]*/ > Ifc2x3::IfcTextStyleFontModel::FontFamily() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(1); return v; }
void Ifc2x3::IfcTextStyleFontModel::setFontFamily(boost::optional< std::vector< std::string > /*[1:?]*/ > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< std::string > Ifc2x3::IfcTextStyleFontModel::FontStyle() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcTextStyleFontModel::setFontStyle(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< std::string > Ifc2x3::IfcTextStyleFontModel::FontVariant() const { if(get_attribute_value(3).isNull()) { return boost::none; } std::string v = get_attribute_value(3); return v; }
void Ifc2x3::IfcTextStyleFontModel::setFontVariant(boost::optional< std::string > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< std::string > Ifc2x3::IfcTextStyleFontModel::FontWeight() const { if(get_attribute_value(4).isNull()) { return boost::none; } std::string v = get_attribute_value(4); return v; }
void Ifc2x3::IfcTextStyleFontModel::setFontWeight(boost::optional< std::string > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
::Ifc2x3::IfcSizeSelect* Ifc2x3::IfcTextStyleFontModel::FontSize() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(5)))->as<::Ifc2x3::IfcSizeSelect>(true); }
void Ifc2x3::IfcTextStyleFontModel::setFontSize(::Ifc2x3::IfcSizeSelect* v) { set_attribute_value(5, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(5); }


const IfcParse::entity& Ifc2x3::IfcTextStyleFontModel::declaration() const { return *((IfcParse::entity*)IFC2X3_types[888]); }
const IfcParse::entity& Ifc2x3::IfcTextStyleFontModel::Class() { return *((IfcParse::entity*)IFC2X3_types[888]); }
Ifc2x3::IfcTextStyleFontModel::IfcTextStyleFontModel(IfcEntityInstanceData&& e) : IfcPreDefinedTextFont(std::move(e)) { }
Ifc2x3::IfcTextStyleFontModel::IfcTextStyleFontModel(std::string v1_Name, boost::optional< std::vector< std::string > /*[1:?]*/ > v2_FontFamily, boost::optional< std::string > v3_FontStyle, boost::optional< std::string > v4_FontVariant, boost::optional< std::string > v5_FontWeight, ::Ifc2x3::IfcSizeSelect* v6_FontSize) : IfcPreDefinedTextFont(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_Name)); if (v2_FontFamily) {set_attribute_value(1, (*v2_FontFamily)); } if (v3_FontStyle) {set_attribute_value(2, (*v3_FontStyle)); } if (v4_FontVariant) {set_attribute_value(3, (*v4_FontVariant)); } if (v5_FontWeight) {set_attribute_value(4, (*v5_FontWeight)); }set_attribute_value(5, v6_FontSize ? v6_FontSize->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcTextStyleForDefinedFont
::Ifc2x3::IfcColour* Ifc2x3::IfcTextStyleForDefinedFont::Colour() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcColour>(true); }
void Ifc2x3::IfcTextStyleForDefinedFont::setColour(::Ifc2x3::IfcColour* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
::Ifc2x3::IfcColour* Ifc2x3::IfcTextStyleForDefinedFont::BackgroundColour() const { if(get_attribute_value(1).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcColour>(true); }
void Ifc2x3::IfcTextStyleForDefinedFont::setBackgroundColour(::Ifc2x3::IfcColour* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcTextStyleForDefinedFont::declaration() const { return *((IfcParse::entity*)IFC2X3_types[889]); }
const IfcParse::entity& Ifc2x3::IfcTextStyleForDefinedFont::Class() { return *((IfcParse::entity*)IFC2X3_types[889]); }
Ifc2x3::IfcTextStyleForDefinedFont::IfcTextStyleForDefinedFont(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcTextStyleForDefinedFont::IfcTextStyleForDefinedFont(::Ifc2x3::IfcColour* v1_Colour, ::Ifc2x3::IfcColour* v2_BackgroundColour) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_Colour ? v1_Colour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_BackgroundColour ? v2_BackgroundColour->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcTextStyleTextModel
::Ifc2x3::IfcSizeSelect* Ifc2x3::IfcTextStyleTextModel::TextIndent() const { if(get_attribute_value(0).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcSizeSelect>(true); }
void Ifc2x3::IfcTextStyleTextModel::setTextIndent(::Ifc2x3::IfcSizeSelect* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
boost::optional< std::string > Ifc2x3::IfcTextStyleTextModel::TextAlign() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcTextStyleTextModel::setTextAlign(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< std::string > Ifc2x3::IfcTextStyleTextModel::TextDecoration() const { if(get_attribute_value(2).isNull()) { return boost::none; } std::string v = get_attribute_value(2); return v; }
void Ifc2x3::IfcTextStyleTextModel::setTextDecoration(boost::optional< std::string > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
::Ifc2x3::IfcSizeSelect* Ifc2x3::IfcTextStyleTextModel::LetterSpacing() const { if(get_attribute_value(3).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcSizeSelect>(true); }
void Ifc2x3::IfcTextStyleTextModel::setLetterSpacing(::Ifc2x3::IfcSizeSelect* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }
::Ifc2x3::IfcSizeSelect* Ifc2x3::IfcTextStyleTextModel::WordSpacing() const { if(get_attribute_value(4).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcSizeSelect>(true); }
void Ifc2x3::IfcTextStyleTextModel::setWordSpacing(::Ifc2x3::IfcSizeSelect* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }
boost::optional< std::string > Ifc2x3::IfcTextStyleTextModel::TextTransform() const { if(get_attribute_value(5).isNull()) { return boost::none; } std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcTextStyleTextModel::setTextTransform(boost::optional< std::string > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
::Ifc2x3::IfcSizeSelect* Ifc2x3::IfcTextStyleTextModel::LineHeight() const { if(get_attribute_value(6).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcSizeSelect>(true); }
void Ifc2x3::IfcTextStyleTextModel::setLineHeight(::Ifc2x3::IfcSizeSelect* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcTextStyleTextModel::declaration() const { return *((IfcParse::entity*)IFC2X3_types[891]); }
const IfcParse::entity& Ifc2x3::IfcTextStyleTextModel::Class() { return *((IfcParse::entity*)IFC2X3_types[891]); }
Ifc2x3::IfcTextStyleTextModel::IfcTextStyleTextModel(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcTextStyleTextModel::IfcTextStyleTextModel(::Ifc2x3::IfcSizeSelect* v1_TextIndent, boost::optional< std::string > v2_TextAlign, boost::optional< std::string > v3_TextDecoration, ::Ifc2x3::IfcSizeSelect* v4_LetterSpacing, ::Ifc2x3::IfcSizeSelect* v5_WordSpacing, boost::optional< std::string > v6_TextTransform, ::Ifc2x3::IfcSizeSelect* v7_LineHeight) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, v1_TextIndent ? v1_TextIndent->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_TextAlign) {set_attribute_value(1, (*v2_TextAlign)); } if (v3_TextDecoration) {set_attribute_value(2, (*v3_TextDecoration)); }set_attribute_value(3, v4_LetterSpacing ? v4_LetterSpacing->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(4, v5_WordSpacing ? v5_WordSpacing->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v6_TextTransform) {set_attribute_value(5, (*v6_TextTransform)); }set_attribute_value(6, v7_LineHeight ? v7_LineHeight->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcTextStyleWithBoxCharacteristics
boost::optional< double > Ifc2x3::IfcTextStyleWithBoxCharacteristics::BoxHeight() const { if(get_attribute_value(0).isNull()) { return boost::none; } double v = get_attribute_value(0); return v; }
void Ifc2x3::IfcTextStyleWithBoxCharacteristics::setBoxHeight(boost::optional< double > v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
boost::optional< double > Ifc2x3::IfcTextStyleWithBoxCharacteristics::BoxWidth() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcTextStyleWithBoxCharacteristics::setBoxWidth(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcTextStyleWithBoxCharacteristics::BoxSlantAngle() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcTextStyleWithBoxCharacteristics::setBoxSlantAngle(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcTextStyleWithBoxCharacteristics::BoxRotateAngle() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcTextStyleWithBoxCharacteristics::setBoxRotateAngle(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
::Ifc2x3::IfcSizeSelect* Ifc2x3::IfcTextStyleWithBoxCharacteristics::CharacterSpacing() const { if(get_attribute_value(4).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(4)))->as<::Ifc2x3::IfcSizeSelect>(true); }
void Ifc2x3::IfcTextStyleWithBoxCharacteristics::setCharacterSpacing(::Ifc2x3::IfcSizeSelect* v) { set_attribute_value(4, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcTextStyleWithBoxCharacteristics::declaration() const { return *((IfcParse::entity*)IFC2X3_types[892]); }
const IfcParse::entity& Ifc2x3::IfcTextStyleWithBoxCharacteristics::Class() { return *((IfcParse::entity*)IFC2X3_types[892]); }
Ifc2x3::IfcTextStyleWithBoxCharacteristics::IfcTextStyleWithBoxCharacteristics(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcTextStyleWithBoxCharacteristics::IfcTextStyleWithBoxCharacteristics(boost::optional< double > v1_BoxHeight, boost::optional< double > v2_BoxWidth, boost::optional< double > v3_BoxSlantAngle, boost::optional< double > v4_BoxRotateAngle, ::Ifc2x3::IfcSizeSelect* v5_CharacterSpacing) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(5))) {  if (v1_BoxHeight) {set_attribute_value(0, (*v1_BoxHeight)); } if (v2_BoxWidth) {set_attribute_value(1, (*v2_BoxWidth)); } if (v3_BoxSlantAngle) {set_attribute_value(2, (*v3_BoxSlantAngle)); } if (v4_BoxRotateAngle) {set_attribute_value(3, (*v4_BoxRotateAngle)); }set_attribute_value(4, v5_CharacterSpacing ? v5_CharacterSpacing->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcTextureCoordinate

::Ifc2x3::IfcAnnotationSurface::list::ptr Ifc2x3::IfcTextureCoordinate::AnnotatedSurface() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[32], 1)->as<IfcAnnotationSurface>(); }

const IfcParse::entity& Ifc2x3::IfcTextureCoordinate::declaration() const { return *((IfcParse::entity*)IFC2X3_types[894]); }
const IfcParse::entity& Ifc2x3::IfcTextureCoordinate::Class() { return *((IfcParse::entity*)IFC2X3_types[894]); }
Ifc2x3::IfcTextureCoordinate::IfcTextureCoordinate(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcTextureCoordinate::IfcTextureCoordinate() : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(0))) { ; populate_derived(); }

// Function implementations for IfcTextureCoordinateGenerator
std::string Ifc2x3::IfcTextureCoordinateGenerator::Mode() const {  std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcTextureCoordinateGenerator::setMode(std::string v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcSimpleValue >::ptr Ifc2x3::IfcTextureCoordinateGenerator::Parameter() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcSimpleValue >(); }
void Ifc2x3::IfcTextureCoordinateGenerator::setParameter(aggregate_of< ::Ifc2x3::IfcSimpleValue >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcTextureCoordinateGenerator::declaration() const { return *((IfcParse::entity*)IFC2X3_types[895]); }
const IfcParse::entity& Ifc2x3::IfcTextureCoordinateGenerator::Class() { return *((IfcParse::entity*)IFC2X3_types[895]); }
Ifc2x3::IfcTextureCoordinateGenerator::IfcTextureCoordinateGenerator(IfcEntityInstanceData&& e) : IfcTextureCoordinate(std::move(e)) { }
Ifc2x3::IfcTextureCoordinateGenerator::IfcTextureCoordinateGenerator(std::string v1_Mode, aggregate_of< ::Ifc2x3::IfcSimpleValue >::ptr v2_Parameter) : IfcTextureCoordinate(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (v1_Mode));set_attribute_value(1, (v2_Parameter)->generalize());; populate_derived(); }

// Function implementations for IfcTextureMap
aggregate_of< ::Ifc2x3::IfcVertexBasedTextureMap >::ptr Ifc2x3::IfcTextureMap::TextureMaps() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcVertexBasedTextureMap >(); }
void Ifc2x3::IfcTextureMap::setTextureMaps(aggregate_of< ::Ifc2x3::IfcVertexBasedTextureMap >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcTextureMap::declaration() const { return *((IfcParse::entity*)IFC2X3_types[896]); }
const IfcParse::entity& Ifc2x3::IfcTextureMap::Class() { return *((IfcParse::entity*)IFC2X3_types[896]); }
Ifc2x3::IfcTextureMap::IfcTextureMap(IfcEntityInstanceData&& e) : IfcTextureCoordinate(std::move(e)) { }
Ifc2x3::IfcTextureMap::IfcTextureMap(aggregate_of< ::Ifc2x3::IfcVertexBasedTextureMap >::ptr v1_TextureMaps) : IfcTextureCoordinate(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_TextureMaps)->generalize());; populate_derived(); }

// Function implementations for IfcTextureVertex
std::vector< double > /*[2:2]*/ Ifc2x3::IfcTextureVertex::Coordinates() const {  std::vector< double > /*[2:2]*/ v = get_attribute_value(0); return v; }
void Ifc2x3::IfcTextureVertex::setCoordinates(std::vector< double > /*[2:2]*/ v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcTextureVertex::declaration() const { return *((IfcParse::entity*)IFC2X3_types[897]); }
const IfcParse::entity& Ifc2x3::IfcTextureVertex::Class() { return *((IfcParse::entity*)IFC2X3_types[897]); }
Ifc2x3::IfcTextureVertex::IfcTextureVertex(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcTextureVertex::IfcTextureVertex(std::vector< double > /*[2:2]*/ v1_Coordinates) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Coordinates));; populate_derived(); }

// Function implementations for IfcThermalMaterialProperties
boost::optional< double > Ifc2x3::IfcThermalMaterialProperties::SpecificHeatCapacity() const { if(get_attribute_value(1).isNull()) { return boost::none; } double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcThermalMaterialProperties::setSpecificHeatCapacity(boost::optional< double > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcThermalMaterialProperties::BoilingPoint() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcThermalMaterialProperties::setBoilingPoint(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcThermalMaterialProperties::FreezingPoint() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcThermalMaterialProperties::setFreezingPoint(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< double > Ifc2x3::IfcThermalMaterialProperties::ThermalConductivity() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcThermalMaterialProperties::setThermalConductivity(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }


const IfcParse::entity& Ifc2x3::IfcThermalMaterialProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[903]); }
const IfcParse::entity& Ifc2x3::IfcThermalMaterialProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[903]); }
Ifc2x3::IfcThermalMaterialProperties::IfcThermalMaterialProperties(IfcEntityInstanceData&& e) : IfcMaterialProperties(std::move(e)) { }
Ifc2x3::IfcThermalMaterialProperties::IfcThermalMaterialProperties(::Ifc2x3::IfcMaterial* v1_Material, boost::optional< double > v2_SpecificHeatCapacity, boost::optional< double > v3_BoilingPoint, boost::optional< double > v4_FreezingPoint, boost::optional< double > v5_ThermalConductivity) : IfcMaterialProperties(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, v1_Material ? v1_Material->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_SpecificHeatCapacity) {set_attribute_value(1, (*v2_SpecificHeatCapacity)); } if (v3_BoilingPoint) {set_attribute_value(2, (*v3_BoilingPoint)); } if (v4_FreezingPoint) {set_attribute_value(3, (*v4_FreezingPoint)); } if (v5_ThermalConductivity) {set_attribute_value(4, (*v5_ThermalConductivity)); }; populate_derived(); }

// Function implementations for IfcTimeSeries
std::string Ifc2x3::IfcTimeSeries::Name() const {  std::string v = get_attribute_value(0); return v; }
void Ifc2x3::IfcTimeSeries::setName(std::string v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
boost::optional< std::string > Ifc2x3::IfcTimeSeries::Description() const { if(get_attribute_value(1).isNull()) { return boost::none; } std::string v = get_attribute_value(1); return v; }
void Ifc2x3::IfcTimeSeries::setDescription(boost::optional< std::string > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcTimeSeries::StartTime() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(2)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcTimeSeries::setStartTime(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(2, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(2); }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcTimeSeries::EndTime() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(3)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcTimeSeries::setEndTime(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(3, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(3); }
::Ifc2x3::IfcTimeSeriesDataTypeEnum::Value Ifc2x3::IfcTimeSeries::TimeSeriesDataType() const {  return ::Ifc2x3::IfcTimeSeriesDataTypeEnum::FromString(get_attribute_value(4)); }
void Ifc2x3::IfcTimeSeries::setTimeSeriesDataType(::Ifc2x3::IfcTimeSeriesDataTypeEnum::Value v) { set_attribute_value(4, EnumerationReference(&::Ifc2x3::IfcTimeSeriesDataTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcDataOriginEnum::Value Ifc2x3::IfcTimeSeries::DataOrigin() const {  return ::Ifc2x3::IfcDataOriginEnum::FromString(get_attribute_value(5)); }
void Ifc2x3::IfcTimeSeries::setDataOrigin(::Ifc2x3::IfcDataOriginEnum::Value v) { set_attribute_value(5, EnumerationReference(&::Ifc2x3::IfcDataOriginEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(5); }
boost::optional< std::string > Ifc2x3::IfcTimeSeries::UserDefinedDataOrigin() const { if(get_attribute_value(6).isNull()) { return boost::none; } std::string v = get_attribute_value(6); return v; }
void Ifc2x3::IfcTimeSeries::setUserDefinedDataOrigin(boost::optional< std::string > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
::Ifc2x3::IfcUnit* Ifc2x3::IfcTimeSeries::Unit() const { if(get_attribute_value(7).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(7)))->as<::Ifc2x3::IfcUnit>(true); }
void Ifc2x3::IfcTimeSeries::setUnit(::Ifc2x3::IfcUnit* v) { set_attribute_value(7, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(7); }

::Ifc2x3::IfcTimeSeriesReferenceRelationship::list::ptr Ifc2x3::IfcTimeSeries::DocumentedBy() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[910], 0)->as<IfcTimeSeriesReferenceRelationship>(); }

const IfcParse::entity& Ifc2x3::IfcTimeSeries::declaration() const { return *((IfcParse::entity*)IFC2X3_types[908]); }
const IfcParse::entity& Ifc2x3::IfcTimeSeries::Class() { return *((IfcParse::entity*)IFC2X3_types[908]); }
Ifc2x3::IfcTimeSeries::IfcTimeSeries(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcTimeSeries::IfcTimeSeries(std::string v1_Name, boost::optional< std::string > v2_Description, ::Ifc2x3::IfcDateTimeSelect* v3_StartTime, ::Ifc2x3::IfcDateTimeSelect* v4_EndTime, ::Ifc2x3::IfcTimeSeriesDataTypeEnum::Value v5_TimeSeriesDataType, ::Ifc2x3::IfcDataOriginEnum::Value v6_DataOrigin, boost::optional< std::string > v7_UserDefinedDataOrigin, ::Ifc2x3::IfcUnit* v8_Unit) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, v3_StartTime ? v3_StartTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, v4_EndTime ? v4_EndTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(4, (EnumerationReference(&::Ifc2x3::IfcTimeSeriesDataTypeEnum::Class(),(size_t)v5_TimeSeriesDataType)));set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcDataOriginEnum::Class(),(size_t)v6_DataOrigin))); if (v7_UserDefinedDataOrigin) {set_attribute_value(6, (*v7_UserDefinedDataOrigin)); }set_attribute_value(7, v8_Unit ? v8_Unit->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcTimeSeriesReferenceRelationship
::Ifc2x3::IfcTimeSeries* Ifc2x3::IfcTimeSeriesReferenceRelationship::ReferencedTimeSeries() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcTimeSeries>(true); }
void Ifc2x3::IfcTimeSeriesReferenceRelationship::setReferencedTimeSeries(::Ifc2x3::IfcTimeSeries* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcDocumentSelect >::ptr Ifc2x3::IfcTimeSeriesReferenceRelationship::TimeSeriesReferences() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcDocumentSelect >(); }
void Ifc2x3::IfcTimeSeriesReferenceRelationship::setTimeSeriesReferences(aggregate_of< ::Ifc2x3::IfcDocumentSelect >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcTimeSeriesReferenceRelationship::declaration() const { return *((IfcParse::entity*)IFC2X3_types[910]); }
const IfcParse::entity& Ifc2x3::IfcTimeSeriesReferenceRelationship::Class() { return *((IfcParse::entity*)IFC2X3_types[910]); }
Ifc2x3::IfcTimeSeriesReferenceRelationship::IfcTimeSeriesReferenceRelationship(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcTimeSeriesReferenceRelationship::IfcTimeSeriesReferenceRelationship(::Ifc2x3::IfcTimeSeries* v1_ReferencedTimeSeries, aggregate_of< ::Ifc2x3::IfcDocumentSelect >::ptr v2_TimeSeriesReferences) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_ReferencedTimeSeries ? v1_ReferencedTimeSeries->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_TimeSeriesReferences)->generalize());; populate_derived(); }

// Function implementations for IfcTimeSeriesSchedule
boost::optional< aggregate_of< ::Ifc2x3::IfcDateTimeSelect >::ptr > Ifc2x3::IfcTimeSeriesSchedule::ApplicableDates() const { if(get_attribute_value(5).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(5); return es->as< ::Ifc2x3::IfcDateTimeSelect >(); }
void Ifc2x3::IfcTimeSeriesSchedule::setApplicableDates(boost::optional< aggregate_of< ::Ifc2x3::IfcDateTimeSelect >::ptr > v) { if (v) {set_attribute_value(5, (*v)->generalize());} else {unset_attribute_value(5);} }
::Ifc2x3::IfcTimeSeriesScheduleTypeEnum::Value Ifc2x3::IfcTimeSeriesSchedule::TimeSeriesScheduleType() const {  return ::Ifc2x3::IfcTimeSeriesScheduleTypeEnum::FromString(get_attribute_value(6)); }
void Ifc2x3::IfcTimeSeriesSchedule::setTimeSeriesScheduleType(::Ifc2x3::IfcTimeSeriesScheduleTypeEnum::Value v) { set_attribute_value(6, EnumerationReference(&::Ifc2x3::IfcTimeSeriesScheduleTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(6); }
::Ifc2x3::IfcTimeSeries* Ifc2x3::IfcTimeSeriesSchedule::TimeSeries() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(7)))->as<::Ifc2x3::IfcTimeSeries>(true); }
void Ifc2x3::IfcTimeSeriesSchedule::setTimeSeries(::Ifc2x3::IfcTimeSeries* v) { set_attribute_value(7, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(7); }


const IfcParse::entity& Ifc2x3::IfcTimeSeriesSchedule::declaration() const { return *((IfcParse::entity*)IFC2X3_types[911]); }
const IfcParse::entity& Ifc2x3::IfcTimeSeriesSchedule::Class() { return *((IfcParse::entity*)IFC2X3_types[911]); }
Ifc2x3::IfcTimeSeriesSchedule::IfcTimeSeriesSchedule(IfcEntityInstanceData&& e) : IfcControl(std::move(e)) { }
Ifc2x3::IfcTimeSeriesSchedule::IfcTimeSeriesSchedule(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, boost::optional< aggregate_of< ::Ifc2x3::IfcDateTimeSelect >::ptr > v6_ApplicableDates, ::Ifc2x3::IfcTimeSeriesScheduleTypeEnum::Value v7_TimeSeriesScheduleType, ::Ifc2x3::IfcTimeSeries* v8_TimeSeries) : IfcControl(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); } if (v6_ApplicableDates) {set_attribute_value(5, (*v6_ApplicableDates)->generalize()); }set_attribute_value(6, (EnumerationReference(&::Ifc2x3::IfcTimeSeriesScheduleTypeEnum::Class(),(size_t)v7_TimeSeriesScheduleType)));set_attribute_value(7, v8_TimeSeries ? v8_TimeSeries->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcTimeSeriesValue
aggregate_of< ::Ifc2x3::IfcValue >::ptr Ifc2x3::IfcTimeSeriesValue::ListValues() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcValue >(); }
void Ifc2x3::IfcTimeSeriesValue::setListValues(aggregate_of< ::Ifc2x3::IfcValue >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcTimeSeriesValue::declaration() const { return *((IfcParse::entity*)IFC2X3_types[913]); }
const IfcParse::entity& Ifc2x3::IfcTimeSeriesValue::Class() { return *((IfcParse::entity*)IFC2X3_types[913]); }
Ifc2x3::IfcTimeSeriesValue::IfcTimeSeriesValue(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcTimeSeriesValue::IfcTimeSeriesValue(aggregate_of< ::Ifc2x3::IfcValue >::ptr v1_ListValues) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_ListValues)->generalize());; populate_derived(); }

// Function implementations for IfcTopologicalRepresentationItem


const IfcParse::entity& Ifc2x3::IfcTopologicalRepresentationItem::declaration() const { return *((IfcParse::entity*)IFC2X3_types[915]); }
const IfcParse::entity& Ifc2x3::IfcTopologicalRepresentationItem::Class() { return *((IfcParse::entity*)IFC2X3_types[915]); }
Ifc2x3::IfcTopologicalRepresentationItem::IfcTopologicalRepresentationItem(IfcEntityInstanceData&& e) : IfcRepresentationItem(std::move(e)) { }
Ifc2x3::IfcTopologicalRepresentationItem::IfcTopologicalRepresentationItem() : IfcRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(0))) { ; populate_derived(); }

// Function implementations for IfcTopologyRepresentation


const IfcParse::entity& Ifc2x3::IfcTopologyRepresentation::declaration() const { return *((IfcParse::entity*)IFC2X3_types[916]); }
const IfcParse::entity& Ifc2x3::IfcTopologyRepresentation::Class() { return *((IfcParse::entity*)IFC2X3_types[916]); }
Ifc2x3::IfcTopologyRepresentation::IfcTopologyRepresentation(IfcEntityInstanceData&& e) : IfcShapeModel(std::move(e)) { }
Ifc2x3::IfcTopologyRepresentation::IfcTopologyRepresentation(::Ifc2x3::IfcRepresentationContext* v1_ContextOfItems, boost::optional< std::string > v2_RepresentationIdentifier, boost::optional< std::string > v3_RepresentationType, aggregate_of< ::Ifc2x3::IfcRepresentationItem >::ptr v4_Items) : IfcShapeModel(IfcEntityInstanceData(in_memory_attribute_storage(4))) { set_attribute_value(0, v1_ContextOfItems ? v1_ContextOfItems->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_RepresentationIdentifier) {set_attribute_value(1, (*v2_RepresentationIdentifier)); } if (v3_RepresentationType) {set_attribute_value(2, (*v3_RepresentationType)); }set_attribute_value(3, (v4_Items)->generalize());; populate_derived(); }

// Function implementations for IfcTransformerType
::Ifc2x3::IfcTransformerTypeEnum::Value Ifc2x3::IfcTransformerType::PredefinedType() const {  return ::Ifc2x3::IfcTransformerTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcTransformerType::setPredefinedType(::Ifc2x3::IfcTransformerTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcTransformerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcTransformerType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[918]); }
const IfcParse::entity& Ifc2x3::IfcTransformerType::Class() { return *((IfcParse::entity*)IFC2X3_types[918]); }
Ifc2x3::IfcTransformerType::IfcTransformerType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcTransformerType::IfcTransformerType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcTransformerTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcTransformerTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcTransportElement
boost::optional< ::Ifc2x3::IfcTransportElementTypeEnum::Value > Ifc2x3::IfcTransportElement::OperationType() const { if(get_attribute_value(8).isNull()) { return boost::none; } return ::Ifc2x3::IfcTransportElementTypeEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcTransportElement::setOperationType(boost::optional< ::Ifc2x3::IfcTransportElementTypeEnum::Value > v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcTransportElementTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
boost::optional< double > Ifc2x3::IfcTransportElement::CapacityByWeight() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcTransportElement::setCapacityByWeight(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
boost::optional< double > Ifc2x3::IfcTransportElement::CapacityByNumber() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcTransportElement::setCapacityByNumber(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }


const IfcParse::entity& Ifc2x3::IfcTransportElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[921]); }
const IfcParse::entity& Ifc2x3::IfcTransportElement::Class() { return *((IfcParse::entity*)IFC2X3_types[921]); }
Ifc2x3::IfcTransportElement::IfcTransportElement(IfcEntityInstanceData&& e) : IfcElement(std::move(e)) { }
Ifc2x3::IfcTransportElement::IfcTransportElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< ::Ifc2x3::IfcTransportElementTypeEnum::Value > v9_OperationType, boost::optional< double > v10_CapacityByWeight, boost::optional< double > v11_CapacityByNumber) : IfcElement(IfcEntityInstanceData(in_memory_attribute_storage(11))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_OperationType) {set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcTransportElementTypeEnum::Class(),(size_t)*v9_OperationType))); } if (v10_CapacityByWeight) {set_attribute_value(9, (*v10_CapacityByWeight)); } if (v11_CapacityByNumber) {set_attribute_value(10, (*v11_CapacityByNumber)); }; populate_derived(); }

// Function implementations for IfcTransportElementType
::Ifc2x3::IfcTransportElementTypeEnum::Value Ifc2x3::IfcTransportElementType::PredefinedType() const {  return ::Ifc2x3::IfcTransportElementTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcTransportElementType::setPredefinedType(::Ifc2x3::IfcTransportElementTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcTransportElementTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcTransportElementType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[922]); }
const IfcParse::entity& Ifc2x3::IfcTransportElementType::Class() { return *((IfcParse::entity*)IFC2X3_types[922]); }
Ifc2x3::IfcTransportElementType::IfcTransportElementType(IfcEntityInstanceData&& e) : IfcElementType(std::move(e)) { }
Ifc2x3::IfcTransportElementType::IfcTransportElementType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcTransportElementTypeEnum::Value v10_PredefinedType) : IfcElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcTransportElementTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcTrapeziumProfileDef
double Ifc2x3::IfcTrapeziumProfileDef::BottomXDim() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcTrapeziumProfileDef::setBottomXDim(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
double Ifc2x3::IfcTrapeziumProfileDef::TopXDim() const {  double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcTrapeziumProfileDef::setTopXDim(double v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
double Ifc2x3::IfcTrapeziumProfileDef::YDim() const {  double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcTrapeziumProfileDef::setYDim(double v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
double Ifc2x3::IfcTrapeziumProfileDef::TopXOffset() const {  double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcTrapeziumProfileDef::setTopXOffset(double v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }


const IfcParse::entity& Ifc2x3::IfcTrapeziumProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[924]); }
const IfcParse::entity& Ifc2x3::IfcTrapeziumProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[924]); }
Ifc2x3::IfcTrapeziumProfileDef::IfcTrapeziumProfileDef(IfcEntityInstanceData&& e) : IfcParameterizedProfileDef(std::move(e)) { }
Ifc2x3::IfcTrapeziumProfileDef::IfcTrapeziumProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcAxis2Placement2D* v3_Position, double v4_BottomXDim, double v5_TopXDim, double v6_YDim, double v7_TopXOffset) : IfcParameterizedProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(7))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_BottomXDim));set_attribute_value(4, (v5_TopXDim));set_attribute_value(5, (v6_YDim));set_attribute_value(6, (v7_TopXOffset));; populate_derived(); }

// Function implementations for IfcTrimmedCurve
::Ifc2x3::IfcCurve* Ifc2x3::IfcTrimmedCurve::BasisCurve() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcCurve>(true); }
void Ifc2x3::IfcTrimmedCurve::setBasisCurve(::Ifc2x3::IfcCurve* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcTrimmingSelect >::ptr Ifc2x3::IfcTrimmedCurve::Trim1() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcTrimmingSelect >(); }
void Ifc2x3::IfcTrimmedCurve::setTrim1(aggregate_of< ::Ifc2x3::IfcTrimmingSelect >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }
aggregate_of< ::Ifc2x3::IfcTrimmingSelect >::ptr Ifc2x3::IfcTrimmedCurve::Trim2() const {  aggregate_of_instance::ptr es = get_attribute_value(2); return es->as< ::Ifc2x3::IfcTrimmingSelect >(); }
void Ifc2x3::IfcTrimmedCurve::setTrim2(aggregate_of< ::Ifc2x3::IfcTrimmingSelect >::ptr v) { set_attribute_value(2, (v)->generalize());if constexpr (false)unset_attribute_value(2); }
bool Ifc2x3::IfcTrimmedCurve::SenseAgreement() const {  bool v = get_attribute_value(3); return v; }
void Ifc2x3::IfcTrimmedCurve::setSenseAgreement(bool v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
::Ifc2x3::IfcTrimmingPreference::Value Ifc2x3::IfcTrimmedCurve::MasterRepresentation() const {  return ::Ifc2x3::IfcTrimmingPreference::FromString(get_attribute_value(4)); }
void Ifc2x3::IfcTrimmedCurve::setMasterRepresentation(::Ifc2x3::IfcTrimmingPreference::Value v) { set_attribute_value(4, EnumerationReference(&::Ifc2x3::IfcTrimmingPreference::Class(), (size_t) v));if constexpr (false)unset_attribute_value(4); }


const IfcParse::entity& Ifc2x3::IfcTrimmedCurve::declaration() const { return *((IfcParse::entity*)IFC2X3_types[925]); }
const IfcParse::entity& Ifc2x3::IfcTrimmedCurve::Class() { return *((IfcParse::entity*)IFC2X3_types[925]); }
Ifc2x3::IfcTrimmedCurve::IfcTrimmedCurve(IfcEntityInstanceData&& e) : IfcBoundedCurve(std::move(e)) { }
Ifc2x3::IfcTrimmedCurve::IfcTrimmedCurve(::Ifc2x3::IfcCurve* v1_BasisCurve, aggregate_of< ::Ifc2x3::IfcTrimmingSelect >::ptr v2_Trim1, aggregate_of< ::Ifc2x3::IfcTrimmingSelect >::ptr v3_Trim2, bool v4_SenseAgreement, ::Ifc2x3::IfcTrimmingPreference::Value v5_MasterRepresentation) : IfcBoundedCurve(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, v1_BasisCurve ? v1_BasisCurve->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Trim1)->generalize());set_attribute_value(2, (v3_Trim2)->generalize());set_attribute_value(3, (v4_SenseAgreement));set_attribute_value(4, (EnumerationReference(&::Ifc2x3::IfcTrimmingPreference::Class(),(size_t)v5_MasterRepresentation)));; populate_derived(); }

// Function implementations for IfcTubeBundleType
::Ifc2x3::IfcTubeBundleTypeEnum::Value Ifc2x3::IfcTubeBundleType::PredefinedType() const {  return ::Ifc2x3::IfcTubeBundleTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcTubeBundleType::setPredefinedType(::Ifc2x3::IfcTubeBundleTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcTubeBundleTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcTubeBundleType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[929]); }
const IfcParse::entity& Ifc2x3::IfcTubeBundleType::Class() { return *((IfcParse::entity*)IFC2X3_types[929]); }
Ifc2x3::IfcTubeBundleType::IfcTubeBundleType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcTubeBundleType::IfcTubeBundleType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcTubeBundleTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcTubeBundleTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcTwoDirectionRepeatFactor
::Ifc2x3::IfcVector* Ifc2x3::IfcTwoDirectionRepeatFactor::SecondRepeatFactor() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(1)))->as<::Ifc2x3::IfcVector>(true); }
void Ifc2x3::IfcTwoDirectionRepeatFactor::setSecondRepeatFactor(::Ifc2x3::IfcVector* v) { set_attribute_value(1, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcTwoDirectionRepeatFactor::declaration() const { return *((IfcParse::entity*)IFC2X3_types[931]); }
const IfcParse::entity& Ifc2x3::IfcTwoDirectionRepeatFactor::Class() { return *((IfcParse::entity*)IFC2X3_types[931]); }
Ifc2x3::IfcTwoDirectionRepeatFactor::IfcTwoDirectionRepeatFactor(IfcEntityInstanceData&& e) : IfcOneDirectionRepeatFactor(std::move(e)) { }
Ifc2x3::IfcTwoDirectionRepeatFactor::IfcTwoDirectionRepeatFactor(::Ifc2x3::IfcVector* v1_RepeatFactor, ::Ifc2x3::IfcVector* v2_SecondRepeatFactor) : IfcOneDirectionRepeatFactor(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_RepeatFactor ? v1_RepeatFactor->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, v2_SecondRepeatFactor ? v2_SecondRepeatFactor->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcTypeObject
boost::optional< std::string > Ifc2x3::IfcTypeObject::ApplicableOccurrence() const { if(get_attribute_value(4).isNull()) { return boost::none; } std::string v = get_attribute_value(4); return v; }
void Ifc2x3::IfcTypeObject::setApplicableOccurrence(boost::optional< std::string > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > Ifc2x3::IfcTypeObject::HasPropertySets() const { if(get_attribute_value(5).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(5); return es->as< ::Ifc2x3::IfcPropertySetDefinition >(); }
void Ifc2x3::IfcTypeObject::setHasPropertySets(boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v) { if (v) {set_attribute_value(5, (*v)->generalize());} else {unset_attribute_value(5);} }

::Ifc2x3::IfcRelDefinesByType::list::ptr Ifc2x3::IfcTypeObject::ObjectTypeOf() const { if (!file_) { return nullptr; } return file_->getInverse(id_, IFC2X3_types[704], 5)->as<IfcRelDefinesByType>(); }

const IfcParse::entity& Ifc2x3::IfcTypeObject::declaration() const { return *((IfcParse::entity*)IFC2X3_types[932]); }
const IfcParse::entity& Ifc2x3::IfcTypeObject::Class() { return *((IfcParse::entity*)IFC2X3_types[932]); }
Ifc2x3::IfcTypeObject::IfcTypeObject(IfcEntityInstanceData&& e) : IfcObjectDefinition(std::move(e)) { }
Ifc2x3::IfcTypeObject::IfcTypeObject(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets) : IfcObjectDefinition(IfcEntityInstanceData(in_memory_attribute_storage(6))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); }; populate_derived(); }

// Function implementations for IfcTypeProduct
boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > Ifc2x3::IfcTypeProduct::RepresentationMaps() const { if(get_attribute_value(6).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(6); return es->as< ::Ifc2x3::IfcRepresentationMap >(); }
void Ifc2x3::IfcTypeProduct::setRepresentationMaps(boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v) { if (v) {set_attribute_value(6, (*v)->generalize());} else {unset_attribute_value(6);} }
boost::optional< std::string > Ifc2x3::IfcTypeProduct::Tag() const { if(get_attribute_value(7).isNull()) { return boost::none; } std::string v = get_attribute_value(7); return v; }
void Ifc2x3::IfcTypeProduct::setTag(boost::optional< std::string > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }


const IfcParse::entity& Ifc2x3::IfcTypeProduct::declaration() const { return *((IfcParse::entity*)IFC2X3_types[933]); }
const IfcParse::entity& Ifc2x3::IfcTypeProduct::Class() { return *((IfcParse::entity*)IFC2X3_types[933]); }
Ifc2x3::IfcTypeProduct::IfcTypeProduct(IfcEntityInstanceData&& e) : IfcTypeObject(std::move(e)) { }
Ifc2x3::IfcTypeProduct::IfcTypeProduct(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag) : IfcTypeObject(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcUShapeProfileDef
double Ifc2x3::IfcUShapeProfileDef::Depth() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcUShapeProfileDef::setDepth(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
double Ifc2x3::IfcUShapeProfileDef::FlangeWidth() const {  double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcUShapeProfileDef::setFlangeWidth(double v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
double Ifc2x3::IfcUShapeProfileDef::WebThickness() const {  double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcUShapeProfileDef::setWebThickness(double v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
double Ifc2x3::IfcUShapeProfileDef::FlangeThickness() const {  double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcUShapeProfileDef::setFlangeThickness(double v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
boost::optional< double > Ifc2x3::IfcUShapeProfileDef::FilletRadius() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcUShapeProfileDef::setFilletRadius(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
boost::optional< double > Ifc2x3::IfcUShapeProfileDef::EdgeRadius() const { if(get_attribute_value(8).isNull()) { return boost::none; } double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcUShapeProfileDef::setEdgeRadius(boost::optional< double > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
boost::optional< double > Ifc2x3::IfcUShapeProfileDef::FlangeSlope() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcUShapeProfileDef::setFlangeSlope(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
boost::optional< double > Ifc2x3::IfcUShapeProfileDef::CentreOfGravityInX() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcUShapeProfileDef::setCentreOfGravityInX(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }


const IfcParse::entity& Ifc2x3::IfcUShapeProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[939]); }
const IfcParse::entity& Ifc2x3::IfcUShapeProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[939]); }
Ifc2x3::IfcUShapeProfileDef::IfcUShapeProfileDef(IfcEntityInstanceData&& e) : IfcParameterizedProfileDef(std::move(e)) { }
Ifc2x3::IfcUShapeProfileDef::IfcUShapeProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcAxis2Placement2D* v3_Position, double v4_Depth, double v5_FlangeWidth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius, boost::optional< double > v9_EdgeRadius, boost::optional< double > v10_FlangeSlope, boost::optional< double > v11_CentreOfGravityInX) : IfcParameterizedProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(11))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_Depth));set_attribute_value(4, (v5_FlangeWidth));set_attribute_value(5, (v6_WebThickness));set_attribute_value(6, (v7_FlangeThickness)); if (v8_FilletRadius) {set_attribute_value(7, (*v8_FilletRadius)); } if (v9_EdgeRadius) {set_attribute_value(8, (*v9_EdgeRadius)); } if (v10_FlangeSlope) {set_attribute_value(9, (*v10_FlangeSlope)); } if (v11_CentreOfGravityInX) {set_attribute_value(10, (*v11_CentreOfGravityInX)); }; populate_derived(); }

// Function implementations for IfcUnitAssignment
aggregate_of< ::Ifc2x3::IfcUnit >::ptr Ifc2x3::IfcUnitAssignment::Units() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcUnit >(); }
void Ifc2x3::IfcUnitAssignment::setUnits(aggregate_of< ::Ifc2x3::IfcUnit >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcUnitAssignment::declaration() const { return *((IfcParse::entity*)IFC2X3_types[937]); }
const IfcParse::entity& Ifc2x3::IfcUnitAssignment::Class() { return *((IfcParse::entity*)IFC2X3_types[937]); }
Ifc2x3::IfcUnitAssignment::IfcUnitAssignment(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcUnitAssignment::IfcUnitAssignment(aggregate_of< ::Ifc2x3::IfcUnit >::ptr v1_Units) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, (v1_Units)->generalize());; populate_derived(); }

// Function implementations for IfcUnitaryEquipmentType
::Ifc2x3::IfcUnitaryEquipmentTypeEnum::Value Ifc2x3::IfcUnitaryEquipmentType::PredefinedType() const {  return ::Ifc2x3::IfcUnitaryEquipmentTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcUnitaryEquipmentType::setPredefinedType(::Ifc2x3::IfcUnitaryEquipmentTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcUnitaryEquipmentTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcUnitaryEquipmentType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[935]); }
const IfcParse::entity& Ifc2x3::IfcUnitaryEquipmentType::Class() { return *((IfcParse::entity*)IFC2X3_types[935]); }
Ifc2x3::IfcUnitaryEquipmentType::IfcUnitaryEquipmentType(IfcEntityInstanceData&& e) : IfcEnergyConversionDeviceType(std::move(e)) { }
Ifc2x3::IfcUnitaryEquipmentType::IfcUnitaryEquipmentType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcUnitaryEquipmentTypeEnum::Value v10_PredefinedType) : IfcEnergyConversionDeviceType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcUnitaryEquipmentTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcValveType
::Ifc2x3::IfcValveTypeEnum::Value Ifc2x3::IfcValveType::PredefinedType() const {  return ::Ifc2x3::IfcValveTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcValveType::setPredefinedType(::Ifc2x3::IfcValveTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcValveTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcValveType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[941]); }
const IfcParse::entity& Ifc2x3::IfcValveType::Class() { return *((IfcParse::entity*)IFC2X3_types[941]); }
Ifc2x3::IfcValveType::IfcValveType(IfcEntityInstanceData&& e) : IfcFlowControllerType(std::move(e)) { }
Ifc2x3::IfcValveType::IfcValveType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcValveTypeEnum::Value v10_PredefinedType) : IfcFlowControllerType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcValveTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcVector
::Ifc2x3::IfcDirection* Ifc2x3::IfcVector::Orientation() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcDirection>(true); }
void Ifc2x3::IfcVector::setOrientation(::Ifc2x3::IfcDirection* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }
double Ifc2x3::IfcVector::Magnitude() const {  double v = get_attribute_value(1); return v; }
void Ifc2x3::IfcVector::setMagnitude(double v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcVector::declaration() const { return *((IfcParse::entity*)IFC2X3_types[944]); }
const IfcParse::entity& Ifc2x3::IfcVector::Class() { return *((IfcParse::entity*)IFC2X3_types[944]); }
Ifc2x3::IfcVector::IfcVector(IfcEntityInstanceData&& e) : IfcGeometricRepresentationItem(std::move(e)) { }
Ifc2x3::IfcVector::IfcVector(::Ifc2x3::IfcDirection* v1_Orientation, double v2_Magnitude) : IfcGeometricRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, v1_Orientation ? v1_Orientation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(1, (v2_Magnitude));; populate_derived(); }

// Function implementations for IfcVertex


const IfcParse::entity& Ifc2x3::IfcVertex::declaration() const { return *((IfcParse::entity*)IFC2X3_types[946]); }
const IfcParse::entity& Ifc2x3::IfcVertex::Class() { return *((IfcParse::entity*)IFC2X3_types[946]); }
Ifc2x3::IfcVertex::IfcVertex(IfcEntityInstanceData&& e) : IfcTopologicalRepresentationItem(std::move(e)) { }
Ifc2x3::IfcVertex::IfcVertex() : IfcTopologicalRepresentationItem(IfcEntityInstanceData(in_memory_attribute_storage(0))) { ; populate_derived(); }

// Function implementations for IfcVertexBasedTextureMap
aggregate_of< ::Ifc2x3::IfcTextureVertex >::ptr Ifc2x3::IfcVertexBasedTextureMap::TextureVertices() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcTextureVertex >(); }
void Ifc2x3::IfcVertexBasedTextureMap::setTextureVertices(aggregate_of< ::Ifc2x3::IfcTextureVertex >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }
aggregate_of< ::Ifc2x3::IfcCartesianPoint >::ptr Ifc2x3::IfcVertexBasedTextureMap::TexturePoints() const {  aggregate_of_instance::ptr es = get_attribute_value(1); return es->as< ::Ifc2x3::IfcCartesianPoint >(); }
void Ifc2x3::IfcVertexBasedTextureMap::setTexturePoints(aggregate_of< ::Ifc2x3::IfcCartesianPoint >::ptr v) { set_attribute_value(1, (v)->generalize());if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcVertexBasedTextureMap::declaration() const { return *((IfcParse::entity*)IFC2X3_types[947]); }
const IfcParse::entity& Ifc2x3::IfcVertexBasedTextureMap::Class() { return *((IfcParse::entity*)IFC2X3_types[947]); }
Ifc2x3::IfcVertexBasedTextureMap::IfcVertexBasedTextureMap(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcVertexBasedTextureMap::IfcVertexBasedTextureMap(aggregate_of< ::Ifc2x3::IfcTextureVertex >::ptr v1_TextureVertices, aggregate_of< ::Ifc2x3::IfcCartesianPoint >::ptr v2_TexturePoints) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (v1_TextureVertices)->generalize());set_attribute_value(1, (v2_TexturePoints)->generalize());; populate_derived(); }

// Function implementations for IfcVertexLoop
::Ifc2x3::IfcVertex* Ifc2x3::IfcVertexLoop::LoopVertex() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcVertex>(true); }
void Ifc2x3::IfcVertexLoop::setLoopVertex(::Ifc2x3::IfcVertex* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcVertexLoop::declaration() const { return *((IfcParse::entity*)IFC2X3_types[948]); }
const IfcParse::entity& Ifc2x3::IfcVertexLoop::Class() { return *((IfcParse::entity*)IFC2X3_types[948]); }
Ifc2x3::IfcVertexLoop::IfcVertexLoop(IfcEntityInstanceData&& e) : IfcLoop(std::move(e)) { }
Ifc2x3::IfcVertexLoop::IfcVertexLoop(::Ifc2x3::IfcVertex* v1_LoopVertex) : IfcLoop(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, v1_LoopVertex ? v1_LoopVertex->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcVertexPoint
::Ifc2x3::IfcPoint* Ifc2x3::IfcVertexPoint::VertexGeometry() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(0)))->as<::Ifc2x3::IfcPoint>(true); }
void Ifc2x3::IfcVertexPoint::setVertexGeometry(::Ifc2x3::IfcPoint* v) { set_attribute_value(0, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(0); }


const IfcParse::entity& Ifc2x3::IfcVertexPoint::declaration() const { return *((IfcParse::entity*)IFC2X3_types[949]); }
const IfcParse::entity& Ifc2x3::IfcVertexPoint::Class() { return *((IfcParse::entity*)IFC2X3_types[949]); }
Ifc2x3::IfcVertexPoint::IfcVertexPoint(IfcEntityInstanceData&& e) : IfcVertex(std::move(e)) { }
Ifc2x3::IfcVertexPoint::IfcVertexPoint(::Ifc2x3::IfcPoint* v1_VertexGeometry) : IfcVertex(IfcEntityInstanceData(in_memory_attribute_storage(1))) { set_attribute_value(0, v1_VertexGeometry ? v1_VertexGeometry->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcVibrationIsolatorType
::Ifc2x3::IfcVibrationIsolatorTypeEnum::Value Ifc2x3::IfcVibrationIsolatorType::PredefinedType() const {  return ::Ifc2x3::IfcVibrationIsolatorTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcVibrationIsolatorType::setPredefinedType(::Ifc2x3::IfcVibrationIsolatorTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcVibrationIsolatorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcVibrationIsolatorType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[950]); }
const IfcParse::entity& Ifc2x3::IfcVibrationIsolatorType::Class() { return *((IfcParse::entity*)IFC2X3_types[950]); }
Ifc2x3::IfcVibrationIsolatorType::IfcVibrationIsolatorType(IfcEntityInstanceData&& e) : IfcDiscreteAccessoryType(std::move(e)) { }
Ifc2x3::IfcVibrationIsolatorType::IfcVibrationIsolatorType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcVibrationIsolatorTypeEnum::Value v10_PredefinedType) : IfcDiscreteAccessoryType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcVibrationIsolatorTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcVirtualElement


const IfcParse::entity& Ifc2x3::IfcVirtualElement::declaration() const { return *((IfcParse::entity*)IFC2X3_types[952]); }
const IfcParse::entity& Ifc2x3::IfcVirtualElement::Class() { return *((IfcParse::entity*)IFC2X3_types[952]); }
Ifc2x3::IfcVirtualElement::IfcVirtualElement(IfcEntityInstanceData&& e) : IfcElement(std::move(e)) { }
Ifc2x3::IfcVirtualElement::IfcVirtualElement(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcVirtualGridIntersection
aggregate_of< ::Ifc2x3::IfcGridAxis >::ptr Ifc2x3::IfcVirtualGridIntersection::IntersectingAxes() const {  aggregate_of_instance::ptr es = get_attribute_value(0); return es->as< ::Ifc2x3::IfcGridAxis >(); }
void Ifc2x3::IfcVirtualGridIntersection::setIntersectingAxes(aggregate_of< ::Ifc2x3::IfcGridAxis >::ptr v) { set_attribute_value(0, (v)->generalize());if constexpr (false)unset_attribute_value(0); }
std::vector< double > /*[2:3]*/ Ifc2x3::IfcVirtualGridIntersection::OffsetDistances() const {  std::vector< double > /*[2:3]*/ v = get_attribute_value(1); return v; }
void Ifc2x3::IfcVirtualGridIntersection::setOffsetDistances(std::vector< double > /*[2:3]*/ v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }


const IfcParse::entity& Ifc2x3::IfcVirtualGridIntersection::declaration() const { return *((IfcParse::entity*)IFC2X3_types[953]); }
const IfcParse::entity& Ifc2x3::IfcVirtualGridIntersection::Class() { return *((IfcParse::entity*)IFC2X3_types[953]); }
Ifc2x3::IfcVirtualGridIntersection::IfcVirtualGridIntersection(IfcEntityInstanceData&& e) : IfcUtil::IfcBaseEntity(std::move(e)) { }
Ifc2x3::IfcVirtualGridIntersection::IfcVirtualGridIntersection(aggregate_of< ::Ifc2x3::IfcGridAxis >::ptr v1_IntersectingAxes, std::vector< double > /*[2:3]*/ v2_OffsetDistances) : IfcUtil::IfcBaseEntity(IfcEntityInstanceData(in_memory_attribute_storage(2))) { set_attribute_value(0, (v1_IntersectingAxes)->generalize());set_attribute_value(1, (v2_OffsetDistances));; populate_derived(); }

// Function implementations for IfcWall


const IfcParse::entity& Ifc2x3::IfcWall::declaration() const { return *((IfcParse::entity*)IFC2X3_types[956]); }
const IfcParse::entity& Ifc2x3::IfcWall::Class() { return *((IfcParse::entity*)IFC2X3_types[956]); }
Ifc2x3::IfcWall::IfcWall(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcWall::IfcWall(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcWallStandardCase


const IfcParse::entity& Ifc2x3::IfcWallStandardCase::declaration() const { return *((IfcParse::entity*)IFC2X3_types[957]); }
const IfcParse::entity& Ifc2x3::IfcWallStandardCase::Class() { return *((IfcParse::entity*)IFC2X3_types[957]); }
Ifc2x3::IfcWallStandardCase::IfcWallStandardCase(IfcEntityInstanceData&& e) : IfcWall(std::move(e)) { }
Ifc2x3::IfcWallStandardCase::IfcWallStandardCase(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag) : IfcWall(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }; populate_derived(); }

// Function implementations for IfcWallType
::Ifc2x3::IfcWallTypeEnum::Value Ifc2x3::IfcWallType::PredefinedType() const {  return ::Ifc2x3::IfcWallTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcWallType::setPredefinedType(::Ifc2x3::IfcWallTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcWallTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcWallType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[958]); }
const IfcParse::entity& Ifc2x3::IfcWallType::Class() { return *((IfcParse::entity*)IFC2X3_types[958]); }
Ifc2x3::IfcWallType::IfcWallType(IfcEntityInstanceData&& e) : IfcBuildingElementType(std::move(e)) { }
Ifc2x3::IfcWallType::IfcWallType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcWallTypeEnum::Value v10_PredefinedType) : IfcBuildingElementType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcWallTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcWasteTerminalType
::Ifc2x3::IfcWasteTerminalTypeEnum::Value Ifc2x3::IfcWasteTerminalType::PredefinedType() const {  return ::Ifc2x3::IfcWasteTerminalTypeEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcWasteTerminalType::setPredefinedType(::Ifc2x3::IfcWasteTerminalTypeEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcWasteTerminalTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }


const IfcParse::entity& Ifc2x3::IfcWasteTerminalType::declaration() const { return *((IfcParse::entity*)IFC2X3_types[962]); }
const IfcParse::entity& Ifc2x3::IfcWasteTerminalType::Class() { return *((IfcParse::entity*)IFC2X3_types[962]); }
Ifc2x3::IfcWasteTerminalType::IfcWasteTerminalType(IfcEntityInstanceData&& e) : IfcFlowTerminalType(std::move(e)) { }
Ifc2x3::IfcWasteTerminalType::IfcWasteTerminalType(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, ::Ifc2x3::IfcWasteTerminalTypeEnum::Value v10_PredefinedType) : IfcFlowTerminalType(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcWasteTerminalTypeEnum::Class(),(size_t)v10_PredefinedType)));; populate_derived(); }

// Function implementations for IfcWaterProperties
boost::optional< bool > Ifc2x3::IfcWaterProperties::IsPotable() const { if(get_attribute_value(1).isNull()) { return boost::none; } bool v = get_attribute_value(1); return v; }
void Ifc2x3::IfcWaterProperties::setIsPotable(boost::optional< bool > v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
boost::optional< double > Ifc2x3::IfcWaterProperties::Hardness() const { if(get_attribute_value(2).isNull()) { return boost::none; } double v = get_attribute_value(2); return v; }
void Ifc2x3::IfcWaterProperties::setHardness(boost::optional< double > v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
boost::optional< double > Ifc2x3::IfcWaterProperties::AlkalinityConcentration() const { if(get_attribute_value(3).isNull()) { return boost::none; } double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcWaterProperties::setAlkalinityConcentration(boost::optional< double > v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
boost::optional< double > Ifc2x3::IfcWaterProperties::AcidityConcentration() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcWaterProperties::setAcidityConcentration(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< double > Ifc2x3::IfcWaterProperties::ImpuritiesContent() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcWaterProperties::setImpuritiesContent(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< double > Ifc2x3::IfcWaterProperties::PHLevel() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcWaterProperties::setPHLevel(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
boost::optional< double > Ifc2x3::IfcWaterProperties::DissolvedSolidsContent() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcWaterProperties::setDissolvedSolidsContent(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }


const IfcParse::entity& Ifc2x3::IfcWaterProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[964]); }
const IfcParse::entity& Ifc2x3::IfcWaterProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[964]); }
Ifc2x3::IfcWaterProperties::IfcWaterProperties(IfcEntityInstanceData&& e) : IfcMaterialProperties(std::move(e)) { }
Ifc2x3::IfcWaterProperties::IfcWaterProperties(::Ifc2x3::IfcMaterial* v1_Material, boost::optional< bool > v2_IsPotable, boost::optional< double > v3_Hardness, boost::optional< double > v4_AlkalinityConcentration, boost::optional< double > v5_AcidityConcentration, boost::optional< double > v6_ImpuritiesContent, boost::optional< double > v7_PHLevel, boost::optional< double > v8_DissolvedSolidsContent) : IfcMaterialProperties(IfcEntityInstanceData(in_memory_attribute_storage(8))) { set_attribute_value(0, v1_Material ? v1_Material->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v2_IsPotable) {set_attribute_value(1, (*v2_IsPotable)); } if (v3_Hardness) {set_attribute_value(2, (*v3_Hardness)); } if (v4_AlkalinityConcentration) {set_attribute_value(3, (*v4_AlkalinityConcentration)); } if (v5_AcidityConcentration) {set_attribute_value(4, (*v5_AcidityConcentration)); } if (v6_ImpuritiesContent) {set_attribute_value(5, (*v6_ImpuritiesContent)); } if (v7_PHLevel) {set_attribute_value(6, (*v7_PHLevel)); } if (v8_DissolvedSolidsContent) {set_attribute_value(7, (*v8_DissolvedSolidsContent)); }; populate_derived(); }

// Function implementations for IfcWindow
boost::optional< double > Ifc2x3::IfcWindow::OverallHeight() const { if(get_attribute_value(8).isNull()) { return boost::none; } double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcWindow::setOverallHeight(boost::optional< double > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
boost::optional< double > Ifc2x3::IfcWindow::OverallWidth() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcWindow::setOverallWidth(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }


const IfcParse::entity& Ifc2x3::IfcWindow::declaration() const { return *((IfcParse::entity*)IFC2X3_types[965]); }
const IfcParse::entity& Ifc2x3::IfcWindow::Class() { return *((IfcParse::entity*)IFC2X3_types[965]); }
Ifc2x3::IfcWindow::IfcWindow(IfcEntityInstanceData&& e) : IfcBuildingElement(std::move(e)) { }
Ifc2x3::IfcWindow::IfcWindow(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, ::Ifc2x3::IfcObjectPlacement* v6_ObjectPlacement, ::Ifc2x3::IfcProductRepresentation* v7_Representation, boost::optional< std::string > v8_Tag, boost::optional< double > v9_OverallHeight, boost::optional< double > v10_OverallWidth) : IfcBuildingElement(IfcEntityInstanceData(in_memory_attribute_storage(10))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, v6_ObjectPlacement ? v6_ObjectPlacement->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(6, v7_Representation ? v7_Representation->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_OverallHeight) {set_attribute_value(8, (*v9_OverallHeight)); } if (v10_OverallWidth) {set_attribute_value(9, (*v10_OverallWidth)); }; populate_derived(); }

// Function implementations for IfcWindowLiningProperties
boost::optional< double > Ifc2x3::IfcWindowLiningProperties::LiningDepth() const { if(get_attribute_value(4).isNull()) { return boost::none; } double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcWindowLiningProperties::setLiningDepth(boost::optional< double > v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
boost::optional< double > Ifc2x3::IfcWindowLiningProperties::LiningThickness() const { if(get_attribute_value(5).isNull()) { return boost::none; } double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcWindowLiningProperties::setLiningThickness(boost::optional< double > v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
boost::optional< double > Ifc2x3::IfcWindowLiningProperties::TransomThickness() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcWindowLiningProperties::setTransomThickness(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
boost::optional< double > Ifc2x3::IfcWindowLiningProperties::MullionThickness() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcWindowLiningProperties::setMullionThickness(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
boost::optional< double > Ifc2x3::IfcWindowLiningProperties::FirstTransomOffset() const { if(get_attribute_value(8).isNull()) { return boost::none; } double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcWindowLiningProperties::setFirstTransomOffset(boost::optional< double > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
boost::optional< double > Ifc2x3::IfcWindowLiningProperties::SecondTransomOffset() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcWindowLiningProperties::setSecondTransomOffset(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
boost::optional< double > Ifc2x3::IfcWindowLiningProperties::FirstMullionOffset() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcWindowLiningProperties::setFirstMullionOffset(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
boost::optional< double > Ifc2x3::IfcWindowLiningProperties::SecondMullionOffset() const { if(get_attribute_value(11).isNull()) { return boost::none; } double v = get_attribute_value(11); return v; }
void Ifc2x3::IfcWindowLiningProperties::setSecondMullionOffset(boost::optional< double > v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
::Ifc2x3::IfcShapeAspect* Ifc2x3::IfcWindowLiningProperties::ShapeAspectStyle() const { if(get_attribute_value(12).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(12)))->as<::Ifc2x3::IfcShapeAspect>(true); }
void Ifc2x3::IfcWindowLiningProperties::setShapeAspectStyle(::Ifc2x3::IfcShapeAspect* v) { set_attribute_value(12, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(12); }


const IfcParse::entity& Ifc2x3::IfcWindowLiningProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[966]); }
const IfcParse::entity& Ifc2x3::IfcWindowLiningProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[966]); }
Ifc2x3::IfcWindowLiningProperties::IfcWindowLiningProperties(IfcEntityInstanceData&& e) : IfcPropertySetDefinition(std::move(e)) { }
Ifc2x3::IfcWindowLiningProperties::IfcWindowLiningProperties(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< double > v5_LiningDepth, boost::optional< double > v6_LiningThickness, boost::optional< double > v7_TransomThickness, boost::optional< double > v8_MullionThickness, boost::optional< double > v9_FirstTransomOffset, boost::optional< double > v10_SecondTransomOffset, boost::optional< double > v11_FirstMullionOffset, boost::optional< double > v12_SecondMullionOffset, ::Ifc2x3::IfcShapeAspect* v13_ShapeAspectStyle) : IfcPropertySetDefinition(IfcEntityInstanceData(in_memory_attribute_storage(13))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_LiningDepth) {set_attribute_value(4, (*v5_LiningDepth)); } if (v6_LiningThickness) {set_attribute_value(5, (*v6_LiningThickness)); } if (v7_TransomThickness) {set_attribute_value(6, (*v7_TransomThickness)); } if (v8_MullionThickness) {set_attribute_value(7, (*v8_MullionThickness)); } if (v9_FirstTransomOffset) {set_attribute_value(8, (*v9_FirstTransomOffset)); } if (v10_SecondTransomOffset) {set_attribute_value(9, (*v10_SecondTransomOffset)); } if (v11_FirstMullionOffset) {set_attribute_value(10, (*v11_FirstMullionOffset)); } if (v12_SecondMullionOffset) {set_attribute_value(11, (*v12_SecondMullionOffset)); }set_attribute_value(12, v13_ShapeAspectStyle ? v13_ShapeAspectStyle->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcWindowPanelProperties
::Ifc2x3::IfcWindowPanelOperationEnum::Value Ifc2x3::IfcWindowPanelProperties::OperationType() const {  return ::Ifc2x3::IfcWindowPanelOperationEnum::FromString(get_attribute_value(4)); }
void Ifc2x3::IfcWindowPanelProperties::setOperationType(::Ifc2x3::IfcWindowPanelOperationEnum::Value v) { set_attribute_value(4, EnumerationReference(&::Ifc2x3::IfcWindowPanelOperationEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(4); }
::Ifc2x3::IfcWindowPanelPositionEnum::Value Ifc2x3::IfcWindowPanelProperties::PanelPosition() const {  return ::Ifc2x3::IfcWindowPanelPositionEnum::FromString(get_attribute_value(5)); }
void Ifc2x3::IfcWindowPanelProperties::setPanelPosition(::Ifc2x3::IfcWindowPanelPositionEnum::Value v) { set_attribute_value(5, EnumerationReference(&::Ifc2x3::IfcWindowPanelPositionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(5); }
boost::optional< double > Ifc2x3::IfcWindowPanelProperties::FrameDepth() const { if(get_attribute_value(6).isNull()) { return boost::none; } double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcWindowPanelProperties::setFrameDepth(boost::optional< double > v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
boost::optional< double > Ifc2x3::IfcWindowPanelProperties::FrameThickness() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcWindowPanelProperties::setFrameThickness(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
::Ifc2x3::IfcShapeAspect* Ifc2x3::IfcWindowPanelProperties::ShapeAspectStyle() const { if(get_attribute_value(8).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(8)))->as<::Ifc2x3::IfcShapeAspect>(true); }
void Ifc2x3::IfcWindowPanelProperties::setShapeAspectStyle(::Ifc2x3::IfcShapeAspect* v) { set_attribute_value(8, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(8); }


const IfcParse::entity& Ifc2x3::IfcWindowPanelProperties::declaration() const { return *((IfcParse::entity*)IFC2X3_types[969]); }
const IfcParse::entity& Ifc2x3::IfcWindowPanelProperties::Class() { return *((IfcParse::entity*)IFC2X3_types[969]); }
Ifc2x3::IfcWindowPanelProperties::IfcWindowPanelProperties(IfcEntityInstanceData&& e) : IfcPropertySetDefinition(std::move(e)) { }
Ifc2x3::IfcWindowPanelProperties::IfcWindowPanelProperties(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, ::Ifc2x3::IfcWindowPanelOperationEnum::Value v5_OperationType, ::Ifc2x3::IfcWindowPanelPositionEnum::Value v6_PanelPosition, boost::optional< double > v7_FrameDepth, boost::optional< double > v8_FrameThickness, ::Ifc2x3::IfcShapeAspect* v9_ShapeAspectStyle) : IfcPropertySetDefinition(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (EnumerationReference(&::Ifc2x3::IfcWindowPanelOperationEnum::Class(),(size_t)v5_OperationType)));set_attribute_value(5, (EnumerationReference(&::Ifc2x3::IfcWindowPanelPositionEnum::Class(),(size_t)v6_PanelPosition))); if (v7_FrameDepth) {set_attribute_value(6, (*v7_FrameDepth)); } if (v8_FrameThickness) {set_attribute_value(7, (*v8_FrameThickness)); }set_attribute_value(8, v9_ShapeAspectStyle ? v9_ShapeAspectStyle->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);; populate_derived(); }

// Function implementations for IfcWindowStyle
::Ifc2x3::IfcWindowStyleConstructionEnum::Value Ifc2x3::IfcWindowStyle::ConstructionType() const {  return ::Ifc2x3::IfcWindowStyleConstructionEnum::FromString(get_attribute_value(8)); }
void Ifc2x3::IfcWindowStyle::setConstructionType(::Ifc2x3::IfcWindowStyleConstructionEnum::Value v) { set_attribute_value(8, EnumerationReference(&::Ifc2x3::IfcWindowStyleConstructionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }
::Ifc2x3::IfcWindowStyleOperationEnum::Value Ifc2x3::IfcWindowStyle::OperationType() const {  return ::Ifc2x3::IfcWindowStyleOperationEnum::FromString(get_attribute_value(9)); }
void Ifc2x3::IfcWindowStyle::setOperationType(::Ifc2x3::IfcWindowStyleOperationEnum::Value v) { set_attribute_value(9, EnumerationReference(&::Ifc2x3::IfcWindowStyleOperationEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
bool Ifc2x3::IfcWindowStyle::ParameterTakesPrecedence() const {  bool v = get_attribute_value(10); return v; }
void Ifc2x3::IfcWindowStyle::setParameterTakesPrecedence(bool v) { set_attribute_value(10, v);if constexpr (false)unset_attribute_value(10); }
bool Ifc2x3::IfcWindowStyle::Sizeable() const {  bool v = get_attribute_value(11); return v; }
void Ifc2x3::IfcWindowStyle::setSizeable(bool v) { set_attribute_value(11, v);if constexpr (false)unset_attribute_value(11); }


const IfcParse::entity& Ifc2x3::IfcWindowStyle::declaration() const { return *((IfcParse::entity*)IFC2X3_types[970]); }
const IfcParse::entity& Ifc2x3::IfcWindowStyle::Class() { return *((IfcParse::entity*)IFC2X3_types[970]); }
Ifc2x3::IfcWindowStyle::IfcWindowStyle(IfcEntityInstanceData&& e) : IfcTypeProduct(std::move(e)) { }
Ifc2x3::IfcWindowStyle::IfcWindowStyle(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< aggregate_of< ::Ifc2x3::IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< aggregate_of< ::Ifc2x3::IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, ::Ifc2x3::IfcWindowStyleConstructionEnum::Value v9_ConstructionType, ::Ifc2x3::IfcWindowStyleOperationEnum::Value v10_OperationType, bool v11_ParameterTakesPrecedence, bool v12_Sizeable) : IfcTypeProduct(IfcEntityInstanceData(in_memory_attribute_storage(12))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ApplicableOccurrence) {set_attribute_value(4, (*v5_ApplicableOccurrence)); } if (v6_HasPropertySets) {set_attribute_value(5, (*v6_HasPropertySets)->generalize()); } if (v7_RepresentationMaps) {set_attribute_value(6, (*v7_RepresentationMaps)->generalize()); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }set_attribute_value(8, (EnumerationReference(&::Ifc2x3::IfcWindowStyleConstructionEnum::Class(),(size_t)v9_ConstructionType)));set_attribute_value(9, (EnumerationReference(&::Ifc2x3::IfcWindowStyleOperationEnum::Class(),(size_t)v10_OperationType)));set_attribute_value(10, (v11_ParameterTakesPrecedence));set_attribute_value(11, (v12_Sizeable));; populate_derived(); }

// Function implementations for IfcWorkControl
std::string Ifc2x3::IfcWorkControl::Identifier() const {  std::string v = get_attribute_value(5); return v; }
void Ifc2x3::IfcWorkControl::setIdentifier(std::string v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcWorkControl::CreationDate() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(6)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcWorkControl::setCreationDate(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(6, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(6); }
boost::optional< aggregate_of< ::Ifc2x3::IfcPerson >::ptr > Ifc2x3::IfcWorkControl::Creators() const { if(get_attribute_value(7).isNull()) { return boost::none; } aggregate_of_instance::ptr es = get_attribute_value(7); return es->as< ::Ifc2x3::IfcPerson >(); }
void Ifc2x3::IfcWorkControl::setCreators(boost::optional< aggregate_of< ::Ifc2x3::IfcPerson >::ptr > v) { if (v) {set_attribute_value(7, (*v)->generalize());} else {unset_attribute_value(7);} }
boost::optional< std::string > Ifc2x3::IfcWorkControl::Purpose() const { if(get_attribute_value(8).isNull()) { return boost::none; } std::string v = get_attribute_value(8); return v; }
void Ifc2x3::IfcWorkControl::setPurpose(boost::optional< std::string > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
boost::optional< double > Ifc2x3::IfcWorkControl::Duration() const { if(get_attribute_value(9).isNull()) { return boost::none; } double v = get_attribute_value(9); return v; }
void Ifc2x3::IfcWorkControl::setDuration(boost::optional< double > v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
boost::optional< double > Ifc2x3::IfcWorkControl::TotalFloat() const { if(get_attribute_value(10).isNull()) { return boost::none; } double v = get_attribute_value(10); return v; }
void Ifc2x3::IfcWorkControl::setTotalFloat(boost::optional< double > v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcWorkControl::StartTime() const {  return ((IfcUtil::IfcBaseClass*)(get_attribute_value(11)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcWorkControl::setStartTime(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(11, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(11); }
::Ifc2x3::IfcDateTimeSelect* Ifc2x3::IfcWorkControl::FinishTime() const { if(get_attribute_value(12).isNull()) { return nullptr; } return ((IfcUtil::IfcBaseClass*)(get_attribute_value(12)))->as<::Ifc2x3::IfcDateTimeSelect>(true); }
void Ifc2x3::IfcWorkControl::setFinishTime(::Ifc2x3::IfcDateTimeSelect* v) { set_attribute_value(12, v->as<IfcUtil::IfcBaseClass>());if constexpr (false)unset_attribute_value(12); }
boost::optional< ::Ifc2x3::IfcWorkControlTypeEnum::Value > Ifc2x3::IfcWorkControl::WorkControlType() const { if(get_attribute_value(13).isNull()) { return boost::none; } return ::Ifc2x3::IfcWorkControlTypeEnum::FromString(get_attribute_value(13)); }
void Ifc2x3::IfcWorkControl::setWorkControlType(boost::optional< ::Ifc2x3::IfcWorkControlTypeEnum::Value > v) { if (v) {set_attribute_value(13, EnumerationReference(&::Ifc2x3::IfcWorkControlTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(13);} }
boost::optional< std::string > Ifc2x3::IfcWorkControl::UserDefinedControlType() const { if(get_attribute_value(14).isNull()) { return boost::none; } std::string v = get_attribute_value(14); return v; }
void Ifc2x3::IfcWorkControl::setUserDefinedControlType(boost::optional< std::string > v) { if (v) {set_attribute_value(14, *v);} else {unset_attribute_value(14);} }


const IfcParse::entity& Ifc2x3::IfcWorkControl::declaration() const { return *((IfcParse::entity*)IFC2X3_types[973]); }
const IfcParse::entity& Ifc2x3::IfcWorkControl::Class() { return *((IfcParse::entity*)IFC2X3_types[973]); }
Ifc2x3::IfcWorkControl::IfcWorkControl(IfcEntityInstanceData&& e) : IfcControl(std::move(e)) { }
Ifc2x3::IfcWorkControl::IfcWorkControl(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_Identifier, ::Ifc2x3::IfcDateTimeSelect* v7_CreationDate, boost::optional< aggregate_of< ::Ifc2x3::IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< double > v10_Duration, boost::optional< double > v11_TotalFloat, ::Ifc2x3::IfcDateTimeSelect* v12_StartTime, ::Ifc2x3::IfcDateTimeSelect* v13_FinishTime, boost::optional< ::Ifc2x3::IfcWorkControlTypeEnum::Value > v14_WorkControlType, boost::optional< std::string > v15_UserDefinedControlType) : IfcControl(IfcEntityInstanceData(in_memory_attribute_storage(15))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (v6_Identifier));set_attribute_value(6, v7_CreationDate ? v7_CreationDate->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Creators) {set_attribute_value(7, (*v8_Creators)->generalize()); } if (v9_Purpose) {set_attribute_value(8, (*v9_Purpose)); } if (v10_Duration) {set_attribute_value(9, (*v10_Duration)); } if (v11_TotalFloat) {set_attribute_value(10, (*v11_TotalFloat)); }set_attribute_value(11, v12_StartTime ? v12_StartTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(12, v13_FinishTime ? v13_FinishTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v14_WorkControlType) {set_attribute_value(13, (EnumerationReference(&::Ifc2x3::IfcWorkControlTypeEnum::Class(),(size_t)*v14_WorkControlType))); } if (v15_UserDefinedControlType) {set_attribute_value(14, (*v15_UserDefinedControlType)); }; populate_derived(); }

// Function implementations for IfcWorkPlan


const IfcParse::entity& Ifc2x3::IfcWorkPlan::declaration() const { return *((IfcParse::entity*)IFC2X3_types[975]); }
const IfcParse::entity& Ifc2x3::IfcWorkPlan::Class() { return *((IfcParse::entity*)IFC2X3_types[975]); }
Ifc2x3::IfcWorkPlan::IfcWorkPlan(IfcEntityInstanceData&& e) : IfcWorkControl(std::move(e)) { }
Ifc2x3::IfcWorkPlan::IfcWorkPlan(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_Identifier, ::Ifc2x3::IfcDateTimeSelect* v7_CreationDate, boost::optional< aggregate_of< ::Ifc2x3::IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< double > v10_Duration, boost::optional< double > v11_TotalFloat, ::Ifc2x3::IfcDateTimeSelect* v12_StartTime, ::Ifc2x3::IfcDateTimeSelect* v13_FinishTime, boost::optional< ::Ifc2x3::IfcWorkControlTypeEnum::Value > v14_WorkControlType, boost::optional< std::string > v15_UserDefinedControlType) : IfcWorkControl(IfcEntityInstanceData(in_memory_attribute_storage(15))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (v6_Identifier));set_attribute_value(6, v7_CreationDate ? v7_CreationDate->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Creators) {set_attribute_value(7, (*v8_Creators)->generalize()); } if (v9_Purpose) {set_attribute_value(8, (*v9_Purpose)); } if (v10_Duration) {set_attribute_value(9, (*v10_Duration)); } if (v11_TotalFloat) {set_attribute_value(10, (*v11_TotalFloat)); }set_attribute_value(11, v12_StartTime ? v12_StartTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(12, v13_FinishTime ? v13_FinishTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v14_WorkControlType) {set_attribute_value(13, (EnumerationReference(&::Ifc2x3::IfcWorkControlTypeEnum::Class(),(size_t)*v14_WorkControlType))); } if (v15_UserDefinedControlType) {set_attribute_value(14, (*v15_UserDefinedControlType)); }; populate_derived(); }

// Function implementations for IfcWorkSchedule


const IfcParse::entity& Ifc2x3::IfcWorkSchedule::declaration() const { return *((IfcParse::entity*)IFC2X3_types[976]); }
const IfcParse::entity& Ifc2x3::IfcWorkSchedule::Class() { return *((IfcParse::entity*)IFC2X3_types[976]); }
Ifc2x3::IfcWorkSchedule::IfcWorkSchedule(IfcEntityInstanceData&& e) : IfcWorkControl(std::move(e)) { }
Ifc2x3::IfcWorkSchedule::IfcWorkSchedule(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType, std::string v6_Identifier, ::Ifc2x3::IfcDateTimeSelect* v7_CreationDate, boost::optional< aggregate_of< ::Ifc2x3::IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< double > v10_Duration, boost::optional< double > v11_TotalFloat, ::Ifc2x3::IfcDateTimeSelect* v12_StartTime, ::Ifc2x3::IfcDateTimeSelect* v13_FinishTime, boost::optional< ::Ifc2x3::IfcWorkControlTypeEnum::Value > v14_WorkControlType, boost::optional< std::string > v15_UserDefinedControlType) : IfcWorkControl(IfcEntityInstanceData(in_memory_attribute_storage(15))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }set_attribute_value(5, (v6_Identifier));set_attribute_value(6, v7_CreationDate ? v7_CreationDate->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v8_Creators) {set_attribute_value(7, (*v8_Creators)->generalize()); } if (v9_Purpose) {set_attribute_value(8, (*v9_Purpose)); } if (v10_Duration) {set_attribute_value(9, (*v10_Duration)); } if (v11_TotalFloat) {set_attribute_value(10, (*v11_TotalFloat)); }set_attribute_value(11, v12_StartTime ? v12_StartTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(12, v13_FinishTime ? v13_FinishTime->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v14_WorkControlType) {set_attribute_value(13, (EnumerationReference(&::Ifc2x3::IfcWorkControlTypeEnum::Class(),(size_t)*v14_WorkControlType))); } if (v15_UserDefinedControlType) {set_attribute_value(14, (*v15_UserDefinedControlType)); }; populate_derived(); }

// Function implementations for IfcZShapeProfileDef
double Ifc2x3::IfcZShapeProfileDef::Depth() const {  double v = get_attribute_value(3); return v; }
void Ifc2x3::IfcZShapeProfileDef::setDepth(double v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
double Ifc2x3::IfcZShapeProfileDef::FlangeWidth() const {  double v = get_attribute_value(4); return v; }
void Ifc2x3::IfcZShapeProfileDef::setFlangeWidth(double v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
double Ifc2x3::IfcZShapeProfileDef::WebThickness() const {  double v = get_attribute_value(5); return v; }
void Ifc2x3::IfcZShapeProfileDef::setWebThickness(double v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
double Ifc2x3::IfcZShapeProfileDef::FlangeThickness() const {  double v = get_attribute_value(6); return v; }
void Ifc2x3::IfcZShapeProfileDef::setFlangeThickness(double v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
boost::optional< double > Ifc2x3::IfcZShapeProfileDef::FilletRadius() const { if(get_attribute_value(7).isNull()) { return boost::none; } double v = get_attribute_value(7); return v; }
void Ifc2x3::IfcZShapeProfileDef::setFilletRadius(boost::optional< double > v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
boost::optional< double > Ifc2x3::IfcZShapeProfileDef::EdgeRadius() const { if(get_attribute_value(8).isNull()) { return boost::none; } double v = get_attribute_value(8); return v; }
void Ifc2x3::IfcZShapeProfileDef::setEdgeRadius(boost::optional< double > v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }


const IfcParse::entity& Ifc2x3::IfcZShapeProfileDef::declaration() const { return *((IfcParse::entity*)IFC2X3_types[979]); }
const IfcParse::entity& Ifc2x3::IfcZShapeProfileDef::Class() { return *((IfcParse::entity*)IFC2X3_types[979]); }
Ifc2x3::IfcZShapeProfileDef::IfcZShapeProfileDef(IfcEntityInstanceData&& e) : IfcParameterizedProfileDef(std::move(e)) { }
Ifc2x3::IfcZShapeProfileDef::IfcZShapeProfileDef(::Ifc2x3::IfcProfileTypeEnum::Value v1_ProfileType, boost::optional< std::string > v2_ProfileName, ::Ifc2x3::IfcAxis2Placement2D* v3_Position, double v4_Depth, double v5_FlangeWidth, double v6_WebThickness, double v7_FlangeThickness, boost::optional< double > v8_FilletRadius, boost::optional< double > v9_EdgeRadius) : IfcParameterizedProfileDef(IfcEntityInstanceData(in_memory_attribute_storage(9))) { set_attribute_value(0, (EnumerationReference(&::Ifc2x3::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, v3_Position ? v3_Position->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr);set_attribute_value(3, (v4_Depth));set_attribute_value(4, (v5_FlangeWidth));set_attribute_value(5, (v6_WebThickness));set_attribute_value(6, (v7_FlangeThickness)); if (v8_FilletRadius) {set_attribute_value(7, (*v8_FilletRadius)); } if (v9_EdgeRadius) {set_attribute_value(8, (*v9_EdgeRadius)); }; populate_derived(); }

// Function implementations for IfcZone


const IfcParse::entity& Ifc2x3::IfcZone::declaration() const { return *((IfcParse::entity*)IFC2X3_types[978]); }
const IfcParse::entity& Ifc2x3::IfcZone::Class() { return *((IfcParse::entity*)IFC2X3_types[978]); }
Ifc2x3::IfcZone::IfcZone(IfcEntityInstanceData&& e) : IfcGroup(std::move(e)) { }
Ifc2x3::IfcZone::IfcZone(std::string v1_GlobalId, ::Ifc2x3::IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ObjectType) : IfcGroup(IfcEntityInstanceData(in_memory_attribute_storage(5))) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, v2_OwnerHistory ? v2_OwnerHistory->as<IfcUtil::IfcBaseClass>() : (IfcUtil::IfcBaseClass*) nullptr); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_ObjectType) {set_attribute_value(4, (*v5_ObjectType)); }; populate_derived(); }