mirror of
https://github.com/IfcOpenShell/IfcOpenShell.git
synced 2026-08-10 17:58:20 +00:00
Thomas Krijnen
14608 lines
1.6 MiB
Plaintext
14608 lines
1.6 MiB
Plaintext
/********************************************************************************
|
|
* *
|
|
* 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 IFC4.exp. Do not make modifications *
|
|
* but instead modify the python script that has been used to generate this. *
|
|
* *
|
|
********************************************************************************/
|
|
|
|
#include "../ifcparse/Ifc4.h"
|
|
#include "../ifcparse/IfcSchema.h"
|
|
#include "../ifcparse/IfcException.h"
|
|
#include "../ifcparse/IfcFile.h"
|
|
|
|
#include <map>
|
|
|
|
const char* const Ifc4::Identifier = "IFC4";
|
|
|
|
using namespace IfcParse;
|
|
|
|
// External definitions
|
|
extern declaration* IFC4_types[1173];
|
|
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcActionRequestTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[3]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcActionRequestTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[3]); }
|
|
|
|
/*
|
|
Ifc4::IfcActionRequestTypeEnum::IfcActionRequestTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcActionRequestTypeEnum::IfcActionRequestTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcActionRequestTypeEnum::IfcActionRequestTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcActionRequestTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcActionRequestTypeEnum::IfcActionRequestTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcActionRequestTypeEnum::Value Ifc4::IfcActionRequestTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcActionRequestTypeEnum::Value) Ifc4::IfcActionRequestTypeEnum::IfcActionRequestTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcActionRequestTypeEnum::operator Ifc4::IfcActionRequestTypeEnum::Value() const {
|
|
return (Ifc4::IfcActionRequestTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcActionSourceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[4]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcActionSourceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[4]); }
|
|
|
|
/*
|
|
Ifc4::IfcActionSourceTypeEnum::IfcActionSourceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcActionSourceTypeEnum::IfcActionSourceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcActionSourceTypeEnum::IfcActionSourceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcActionSourceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcActionSourceTypeEnum::IfcActionSourceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcActionSourceTypeEnum::Value Ifc4::IfcActionSourceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcActionSourceTypeEnum::Value) Ifc4::IfcActionSourceTypeEnum::IfcActionSourceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcActionSourceTypeEnum::operator Ifc4::IfcActionSourceTypeEnum::Value() const {
|
|
return (Ifc4::IfcActionSourceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcActionTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[5]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcActionTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[5]); }
|
|
|
|
/*
|
|
Ifc4::IfcActionTypeEnum::IfcActionTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcActionTypeEnum::IfcActionTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcActionTypeEnum::IfcActionTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcActionTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcActionTypeEnum::IfcActionTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcActionTypeEnum::Value Ifc4::IfcActionTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcActionTypeEnum::Value) Ifc4::IfcActionTypeEnum::IfcActionTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcActionTypeEnum::operator Ifc4::IfcActionTypeEnum::Value() const {
|
|
return (Ifc4::IfcActionTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcActuatorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[11]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcActuatorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[11]); }
|
|
|
|
/*
|
|
Ifc4::IfcActuatorTypeEnum::IfcActuatorTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcActuatorTypeEnum::IfcActuatorTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcActuatorTypeEnum::IfcActuatorTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcActuatorTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcActuatorTypeEnum::IfcActuatorTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcActuatorTypeEnum::Value Ifc4::IfcActuatorTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcActuatorTypeEnum::Value) Ifc4::IfcActuatorTypeEnum::IfcActuatorTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcActuatorTypeEnum::operator Ifc4::IfcActuatorTypeEnum::Value() const {
|
|
return (Ifc4::IfcActuatorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcAddressTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[13]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcAddressTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[13]); }
|
|
|
|
/*
|
|
Ifc4::IfcAddressTypeEnum::IfcAddressTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcAddressTypeEnum::IfcAddressTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcAddressTypeEnum::IfcAddressTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcAddressTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcAddressTypeEnum::IfcAddressTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcAddressTypeEnum::Value Ifc4::IfcAddressTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcAddressTypeEnum::Value) Ifc4::IfcAddressTypeEnum::IfcAddressTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcAddressTypeEnum::operator Ifc4::IfcAddressTypeEnum::Value() const {
|
|
return (Ifc4::IfcAddressTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcAirTerminalBoxTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[20]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcAirTerminalBoxTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[20]); }
|
|
|
|
/*
|
|
Ifc4::IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcAirTerminalBoxTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcAirTerminalBoxTypeEnum::Value Ifc4::IfcAirTerminalBoxTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcAirTerminalBoxTypeEnum::Value) Ifc4::IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcAirTerminalBoxTypeEnum::operator Ifc4::IfcAirTerminalBoxTypeEnum::Value() const {
|
|
return (Ifc4::IfcAirTerminalBoxTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcAirTerminalTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[22]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcAirTerminalTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[22]); }
|
|
|
|
/*
|
|
Ifc4::IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcAirTerminalTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcAirTerminalTypeEnum::Value Ifc4::IfcAirTerminalTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcAirTerminalTypeEnum::Value) Ifc4::IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcAirTerminalTypeEnum::operator Ifc4::IfcAirTerminalTypeEnum::Value() const {
|
|
return (Ifc4::IfcAirTerminalTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcAirToAirHeatRecoveryTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[25]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcAirToAirHeatRecoveryTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[25]); }
|
|
|
|
/*
|
|
Ifc4::IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcAirToAirHeatRecoveryTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcAirToAirHeatRecoveryTypeEnum::Value Ifc4::IfcAirToAirHeatRecoveryTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcAirToAirHeatRecoveryTypeEnum::Value) Ifc4::IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcAirToAirHeatRecoveryTypeEnum::operator Ifc4::IfcAirToAirHeatRecoveryTypeEnum::Value() const {
|
|
return (Ifc4::IfcAirToAirHeatRecoveryTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcAlarmTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[28]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcAlarmTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[28]); }
|
|
|
|
/*
|
|
Ifc4::IfcAlarmTypeEnum::IfcAlarmTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcAlarmTypeEnum::IfcAlarmTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcAlarmTypeEnum::IfcAlarmTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcAlarmTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcAlarmTypeEnum::IfcAlarmTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcAlarmTypeEnum::Value Ifc4::IfcAlarmTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcAlarmTypeEnum::Value) Ifc4::IfcAlarmTypeEnum::IfcAlarmTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcAlarmTypeEnum::operator Ifc4::IfcAlarmTypeEnum::Value() const {
|
|
return (Ifc4::IfcAlarmTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcAnalysisModelTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[30]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcAnalysisModelTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[30]); }
|
|
|
|
/*
|
|
Ifc4::IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcAnalysisModelTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcAnalysisModelTypeEnum::Value Ifc4::IfcAnalysisModelTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcAnalysisModelTypeEnum::Value) Ifc4::IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcAnalysisModelTypeEnum::operator Ifc4::IfcAnalysisModelTypeEnum::Value() const {
|
|
return (Ifc4::IfcAnalysisModelTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcAnalysisTheoryTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[31]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcAnalysisTheoryTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[31]); }
|
|
|
|
/*
|
|
Ifc4::IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcAnalysisTheoryTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcAnalysisTheoryTypeEnum::Value Ifc4::IfcAnalysisTheoryTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcAnalysisTheoryTypeEnum::Value) Ifc4::IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcAnalysisTheoryTypeEnum::operator Ifc4::IfcAnalysisTheoryTypeEnum::Value() const {
|
|
return (Ifc4::IfcAnalysisTheoryTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcArithmeticOperatorEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[46]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcArithmeticOperatorEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[46]); }
|
|
|
|
/*
|
|
Ifc4::IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcArithmeticOperatorEnum::ToString(Value v) {
|
|
return Ifc4::IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcArithmeticOperatorEnum::Value Ifc4::IfcArithmeticOperatorEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcArithmeticOperatorEnum::Value) Ifc4::IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcArithmeticOperatorEnum::operator Ifc4::IfcArithmeticOperatorEnum::Value() const {
|
|
return (Ifc4::IfcArithmeticOperatorEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcAssemblyPlaceEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[47]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcAssemblyPlaceEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[47]); }
|
|
|
|
/*
|
|
Ifc4::IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcAssemblyPlaceEnum::ToString(Value v) {
|
|
return Ifc4::IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcAssemblyPlaceEnum::Value Ifc4::IfcAssemblyPlaceEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcAssemblyPlaceEnum::Value) Ifc4::IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcAssemblyPlaceEnum::operator Ifc4::IfcAssemblyPlaceEnum::Value() const {
|
|
return (Ifc4::IfcAssemblyPlaceEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcAudioVisualApplianceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[52]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcAudioVisualApplianceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[52]); }
|
|
|
|
/*
|
|
Ifc4::IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcAudioVisualApplianceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcAudioVisualApplianceTypeEnum::Value Ifc4::IfcAudioVisualApplianceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcAudioVisualApplianceTypeEnum::Value) Ifc4::IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcAudioVisualApplianceTypeEnum::operator Ifc4::IfcAudioVisualApplianceTypeEnum::Value() const {
|
|
return (Ifc4::IfcAudioVisualApplianceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcBSplineCurveForm::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[86]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcBSplineCurveForm::Class() { return *((IfcParse::enumeration_type*)IFC4_types[86]); }
|
|
|
|
/*
|
|
Ifc4::IfcBSplineCurveForm::IfcBSplineCurveForm(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcBSplineCurveForm::IfcBSplineCurveForm(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcBSplineCurveForm::IfcBSplineCurveForm(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcBSplineCurveForm::ToString(Value v) {
|
|
return Ifc4::IfcBSplineCurveForm::IfcBSplineCurveForm::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcBSplineCurveForm::Value Ifc4::IfcBSplineCurveForm::FromString(const std::string& s) {
|
|
return (Ifc4::IfcBSplineCurveForm::Value) Ifc4::IfcBSplineCurveForm::IfcBSplineCurveForm::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcBSplineCurveForm::operator Ifc4::IfcBSplineCurveForm::Value() const {
|
|
return (Ifc4::IfcBSplineCurveForm::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcBSplineSurfaceForm::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[89]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcBSplineSurfaceForm::Class() { return *((IfcParse::enumeration_type*)IFC4_types[89]); }
|
|
|
|
/*
|
|
Ifc4::IfcBSplineSurfaceForm::IfcBSplineSurfaceForm(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcBSplineSurfaceForm::IfcBSplineSurfaceForm(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcBSplineSurfaceForm::IfcBSplineSurfaceForm(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcBSplineSurfaceForm::ToString(Value v) {
|
|
return Ifc4::IfcBSplineSurfaceForm::IfcBSplineSurfaceForm::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcBSplineSurfaceForm::Value Ifc4::IfcBSplineSurfaceForm::FromString(const std::string& s) {
|
|
return (Ifc4::IfcBSplineSurfaceForm::Value) Ifc4::IfcBSplineSurfaceForm::IfcBSplineSurfaceForm::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcBSplineSurfaceForm::operator Ifc4::IfcBSplineSurfaceForm::Value() const {
|
|
return (Ifc4::IfcBSplineSurfaceForm::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcBeamTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[60]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcBeamTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[60]); }
|
|
|
|
/*
|
|
Ifc4::IfcBeamTypeEnum::IfcBeamTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcBeamTypeEnum::IfcBeamTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcBeamTypeEnum::IfcBeamTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcBeamTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcBeamTypeEnum::IfcBeamTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcBeamTypeEnum::Value Ifc4::IfcBeamTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcBeamTypeEnum::Value) Ifc4::IfcBeamTypeEnum::IfcBeamTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcBeamTypeEnum::operator Ifc4::IfcBeamTypeEnum::Value() const {
|
|
return (Ifc4::IfcBeamTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcBenchmarkEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[61]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcBenchmarkEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[61]); }
|
|
|
|
/*
|
|
Ifc4::IfcBenchmarkEnum::IfcBenchmarkEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcBenchmarkEnum::IfcBenchmarkEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcBenchmarkEnum::IfcBenchmarkEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcBenchmarkEnum::ToString(Value v) {
|
|
return Ifc4::IfcBenchmarkEnum::IfcBenchmarkEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcBenchmarkEnum::Value Ifc4::IfcBenchmarkEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcBenchmarkEnum::Value) Ifc4::IfcBenchmarkEnum::IfcBenchmarkEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcBenchmarkEnum::operator Ifc4::IfcBenchmarkEnum::Value() const {
|
|
return (Ifc4::IfcBenchmarkEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcBoilerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[68]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcBoilerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[68]); }
|
|
|
|
/*
|
|
Ifc4::IfcBoilerTypeEnum::IfcBoilerTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcBoilerTypeEnum::IfcBoilerTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcBoilerTypeEnum::IfcBoilerTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcBoilerTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcBoilerTypeEnum::IfcBoilerTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcBoilerTypeEnum::Value Ifc4::IfcBoilerTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcBoilerTypeEnum::Value) Ifc4::IfcBoilerTypeEnum::IfcBoilerTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcBoilerTypeEnum::operator Ifc4::IfcBoilerTypeEnum::Value() const {
|
|
return (Ifc4::IfcBoilerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcBooleanOperator::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[72]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcBooleanOperator::Class() { return *((IfcParse::enumeration_type*)IFC4_types[72]); }
|
|
|
|
/*
|
|
Ifc4::IfcBooleanOperator::IfcBooleanOperator(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcBooleanOperator::IfcBooleanOperator(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcBooleanOperator::IfcBooleanOperator(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcBooleanOperator::ToString(Value v) {
|
|
return Ifc4::IfcBooleanOperator::IfcBooleanOperator::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcBooleanOperator::Value Ifc4::IfcBooleanOperator::FromString(const std::string& s) {
|
|
return (Ifc4::IfcBooleanOperator::Value) Ifc4::IfcBooleanOperator::IfcBooleanOperator::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcBooleanOperator::operator Ifc4::IfcBooleanOperator::Value() const {
|
|
return (Ifc4::IfcBooleanOperator::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcBuildingElementPartTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[95]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcBuildingElementPartTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[95]); }
|
|
|
|
/*
|
|
Ifc4::IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcBuildingElementPartTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcBuildingElementPartTypeEnum::Value Ifc4::IfcBuildingElementPartTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcBuildingElementPartTypeEnum::Value) Ifc4::IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcBuildingElementPartTypeEnum::operator Ifc4::IfcBuildingElementPartTypeEnum::Value() const {
|
|
return (Ifc4::IfcBuildingElementPartTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcBuildingElementProxyTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[98]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcBuildingElementProxyTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[98]); }
|
|
|
|
/*
|
|
Ifc4::IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcBuildingElementProxyTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcBuildingElementProxyTypeEnum::Value Ifc4::IfcBuildingElementProxyTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcBuildingElementProxyTypeEnum::Value) Ifc4::IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcBuildingElementProxyTypeEnum::operator Ifc4::IfcBuildingElementProxyTypeEnum::Value() const {
|
|
return (Ifc4::IfcBuildingElementProxyTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcBuildingSystemTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[102]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcBuildingSystemTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[102]); }
|
|
|
|
/*
|
|
Ifc4::IfcBuildingSystemTypeEnum::IfcBuildingSystemTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcBuildingSystemTypeEnum::IfcBuildingSystemTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcBuildingSystemTypeEnum::IfcBuildingSystemTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcBuildingSystemTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcBuildingSystemTypeEnum::IfcBuildingSystemTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcBuildingSystemTypeEnum::Value Ifc4::IfcBuildingSystemTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcBuildingSystemTypeEnum::Value) Ifc4::IfcBuildingSystemTypeEnum::IfcBuildingSystemTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcBuildingSystemTypeEnum::operator Ifc4::IfcBuildingSystemTypeEnum::Value() const {
|
|
return (Ifc4::IfcBuildingSystemTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcBurnerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[105]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcBurnerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[105]); }
|
|
|
|
/*
|
|
Ifc4::IfcBurnerTypeEnum::IfcBurnerTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcBurnerTypeEnum::IfcBurnerTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcBurnerTypeEnum::IfcBurnerTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcBurnerTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcBurnerTypeEnum::IfcBurnerTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcBurnerTypeEnum::Value Ifc4::IfcBurnerTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcBurnerTypeEnum::Value) Ifc4::IfcBurnerTypeEnum::IfcBurnerTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcBurnerTypeEnum::operator Ifc4::IfcBurnerTypeEnum::Value() const {
|
|
return (Ifc4::IfcBurnerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcCableCarrierFittingTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[108]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcCableCarrierFittingTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[108]); }
|
|
|
|
/*
|
|
Ifc4::IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcCableCarrierFittingTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcCableCarrierFittingTypeEnum::Value Ifc4::IfcCableCarrierFittingTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcCableCarrierFittingTypeEnum::Value) Ifc4::IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcCableCarrierFittingTypeEnum::operator Ifc4::IfcCableCarrierFittingTypeEnum::Value() const {
|
|
return (Ifc4::IfcCableCarrierFittingTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcCableCarrierSegmentTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[111]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcCableCarrierSegmentTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[111]); }
|
|
|
|
/*
|
|
Ifc4::IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcCableCarrierSegmentTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcCableCarrierSegmentTypeEnum::Value Ifc4::IfcCableCarrierSegmentTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcCableCarrierSegmentTypeEnum::Value) Ifc4::IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcCableCarrierSegmentTypeEnum::operator Ifc4::IfcCableCarrierSegmentTypeEnum::Value() const {
|
|
return (Ifc4::IfcCableCarrierSegmentTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcCableFittingTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[114]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcCableFittingTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[114]); }
|
|
|
|
/*
|
|
Ifc4::IfcCableFittingTypeEnum::IfcCableFittingTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcCableFittingTypeEnum::IfcCableFittingTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcCableFittingTypeEnum::IfcCableFittingTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcCableFittingTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcCableFittingTypeEnum::IfcCableFittingTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcCableFittingTypeEnum::Value Ifc4::IfcCableFittingTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcCableFittingTypeEnum::Value) Ifc4::IfcCableFittingTypeEnum::IfcCableFittingTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcCableFittingTypeEnum::operator Ifc4::IfcCableFittingTypeEnum::Value() const {
|
|
return (Ifc4::IfcCableFittingTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcCableSegmentTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[117]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcCableSegmentTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[117]); }
|
|
|
|
/*
|
|
Ifc4::IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcCableSegmentTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcCableSegmentTypeEnum::Value Ifc4::IfcCableSegmentTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcCableSegmentTypeEnum::Value) Ifc4::IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcCableSegmentTypeEnum::operator Ifc4::IfcCableSegmentTypeEnum::Value() const {
|
|
return (Ifc4::IfcCableSegmentTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcChangeActionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[129]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcChangeActionEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[129]); }
|
|
|
|
/*
|
|
Ifc4::IfcChangeActionEnum::IfcChangeActionEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcChangeActionEnum::IfcChangeActionEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcChangeActionEnum::IfcChangeActionEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcChangeActionEnum::ToString(Value v) {
|
|
return Ifc4::IfcChangeActionEnum::IfcChangeActionEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcChangeActionEnum::Value Ifc4::IfcChangeActionEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcChangeActionEnum::Value) Ifc4::IfcChangeActionEnum::IfcChangeActionEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcChangeActionEnum::operator Ifc4::IfcChangeActionEnum::Value() const {
|
|
return (Ifc4::IfcChangeActionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcChillerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[132]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcChillerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[132]); }
|
|
|
|
/*
|
|
Ifc4::IfcChillerTypeEnum::IfcChillerTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcChillerTypeEnum::IfcChillerTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcChillerTypeEnum::IfcChillerTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcChillerTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcChillerTypeEnum::IfcChillerTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcChillerTypeEnum::Value Ifc4::IfcChillerTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcChillerTypeEnum::Value) Ifc4::IfcChillerTypeEnum::IfcChillerTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcChillerTypeEnum::operator Ifc4::IfcChillerTypeEnum::Value() const {
|
|
return (Ifc4::IfcChillerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcChimneyTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[135]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcChimneyTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[135]); }
|
|
|
|
/*
|
|
Ifc4::IfcChimneyTypeEnum::IfcChimneyTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcChimneyTypeEnum::IfcChimneyTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcChimneyTypeEnum::IfcChimneyTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcChimneyTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcChimneyTypeEnum::IfcChimneyTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcChimneyTypeEnum::Value Ifc4::IfcChimneyTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcChimneyTypeEnum::Value) Ifc4::IfcChimneyTypeEnum::IfcChimneyTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcChimneyTypeEnum::operator Ifc4::IfcChimneyTypeEnum::Value() const {
|
|
return (Ifc4::IfcChimneyTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcCoilTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[148]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcCoilTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[148]); }
|
|
|
|
/*
|
|
Ifc4::IfcCoilTypeEnum::IfcCoilTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcCoilTypeEnum::IfcCoilTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcCoilTypeEnum::IfcCoilTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcCoilTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcCoilTypeEnum::IfcCoilTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcCoilTypeEnum::Value Ifc4::IfcCoilTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcCoilTypeEnum::Value) Ifc4::IfcCoilTypeEnum::IfcCoilTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcCoilTypeEnum::operator Ifc4::IfcCoilTypeEnum::Value() const {
|
|
return (Ifc4::IfcCoilTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcColumnTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[157]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcColumnTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[157]); }
|
|
|
|
/*
|
|
Ifc4::IfcColumnTypeEnum::IfcColumnTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcColumnTypeEnum::IfcColumnTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcColumnTypeEnum::IfcColumnTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcColumnTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcColumnTypeEnum::IfcColumnTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcColumnTypeEnum::Value Ifc4::IfcColumnTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcColumnTypeEnum::Value) Ifc4::IfcColumnTypeEnum::IfcColumnTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcColumnTypeEnum::operator Ifc4::IfcColumnTypeEnum::Value() const {
|
|
return (Ifc4::IfcColumnTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcCommunicationsApplianceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[160]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcCommunicationsApplianceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[160]); }
|
|
|
|
/*
|
|
Ifc4::IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcCommunicationsApplianceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcCommunicationsApplianceTypeEnum::Value Ifc4::IfcCommunicationsApplianceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcCommunicationsApplianceTypeEnum::Value) Ifc4::IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcCommunicationsApplianceTypeEnum::operator Ifc4::IfcCommunicationsApplianceTypeEnum::Value() const {
|
|
return (Ifc4::IfcCommunicationsApplianceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcComplexPropertyTemplateTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[164]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcComplexPropertyTemplateTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[164]); }
|
|
|
|
/*
|
|
Ifc4::IfcComplexPropertyTemplateTypeEnum::IfcComplexPropertyTemplateTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcComplexPropertyTemplateTypeEnum::IfcComplexPropertyTemplateTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcComplexPropertyTemplateTypeEnum::IfcComplexPropertyTemplateTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcComplexPropertyTemplateTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcComplexPropertyTemplateTypeEnum::IfcComplexPropertyTemplateTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcComplexPropertyTemplateTypeEnum::Value Ifc4::IfcComplexPropertyTemplateTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcComplexPropertyTemplateTypeEnum::Value) Ifc4::IfcComplexPropertyTemplateTypeEnum::IfcComplexPropertyTemplateTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcComplexPropertyTemplateTypeEnum::operator Ifc4::IfcComplexPropertyTemplateTypeEnum::Value() const {
|
|
return (Ifc4::IfcComplexPropertyTemplateTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcCompressorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[172]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcCompressorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[172]); }
|
|
|
|
/*
|
|
Ifc4::IfcCompressorTypeEnum::IfcCompressorTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcCompressorTypeEnum::IfcCompressorTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcCompressorTypeEnum::IfcCompressorTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcCompressorTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcCompressorTypeEnum::IfcCompressorTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcCompressorTypeEnum::Value Ifc4::IfcCompressorTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcCompressorTypeEnum::Value) Ifc4::IfcCompressorTypeEnum::IfcCompressorTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcCompressorTypeEnum::operator Ifc4::IfcCompressorTypeEnum::Value() const {
|
|
return (Ifc4::IfcCompressorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcCondenserTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[175]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcCondenserTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[175]); }
|
|
|
|
/*
|
|
Ifc4::IfcCondenserTypeEnum::IfcCondenserTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcCondenserTypeEnum::IfcCondenserTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcCondenserTypeEnum::IfcCondenserTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcCondenserTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcCondenserTypeEnum::IfcCondenserTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcCondenserTypeEnum::Value Ifc4::IfcCondenserTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcCondenserTypeEnum::Value) Ifc4::IfcCondenserTypeEnum::IfcCondenserTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcCondenserTypeEnum::operator Ifc4::IfcCondenserTypeEnum::Value() const {
|
|
return (Ifc4::IfcCondenserTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcConnectionTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[183]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcConnectionTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[183]); }
|
|
|
|
/*
|
|
Ifc4::IfcConnectionTypeEnum::IfcConnectionTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcConnectionTypeEnum::IfcConnectionTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcConnectionTypeEnum::IfcConnectionTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcConnectionTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcConnectionTypeEnum::IfcConnectionTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcConnectionTypeEnum::Value Ifc4::IfcConnectionTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcConnectionTypeEnum::Value) Ifc4::IfcConnectionTypeEnum::IfcConnectionTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcConnectionTypeEnum::operator Ifc4::IfcConnectionTypeEnum::Value() const {
|
|
return (Ifc4::IfcConnectionTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcConstraintEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[186]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcConstraintEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[186]); }
|
|
|
|
/*
|
|
Ifc4::IfcConstraintEnum::IfcConstraintEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcConstraintEnum::IfcConstraintEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcConstraintEnum::IfcConstraintEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcConstraintEnum::ToString(Value v) {
|
|
return Ifc4::IfcConstraintEnum::IfcConstraintEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcConstraintEnum::Value Ifc4::IfcConstraintEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcConstraintEnum::Value) Ifc4::IfcConstraintEnum::IfcConstraintEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcConstraintEnum::operator Ifc4::IfcConstraintEnum::Value() const {
|
|
return (Ifc4::IfcConstraintEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcConstructionEquipmentResourceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[189]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcConstructionEquipmentResourceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[189]); }
|
|
|
|
/*
|
|
Ifc4::IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcConstructionEquipmentResourceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcConstructionEquipmentResourceTypeEnum::Value Ifc4::IfcConstructionEquipmentResourceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcConstructionEquipmentResourceTypeEnum::Value) Ifc4::IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcConstructionEquipmentResourceTypeEnum::operator Ifc4::IfcConstructionEquipmentResourceTypeEnum::Value() const {
|
|
return (Ifc4::IfcConstructionEquipmentResourceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcConstructionMaterialResourceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[192]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcConstructionMaterialResourceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[192]); }
|
|
|
|
/*
|
|
Ifc4::IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcConstructionMaterialResourceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcConstructionMaterialResourceTypeEnum::Value Ifc4::IfcConstructionMaterialResourceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcConstructionMaterialResourceTypeEnum::Value) Ifc4::IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcConstructionMaterialResourceTypeEnum::operator Ifc4::IfcConstructionMaterialResourceTypeEnum::Value() const {
|
|
return (Ifc4::IfcConstructionMaterialResourceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcConstructionProductResourceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[195]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcConstructionProductResourceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[195]); }
|
|
|
|
/*
|
|
Ifc4::IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcConstructionProductResourceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcConstructionProductResourceTypeEnum::Value Ifc4::IfcConstructionProductResourceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcConstructionProductResourceTypeEnum::Value) Ifc4::IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcConstructionProductResourceTypeEnum::operator Ifc4::IfcConstructionProductResourceTypeEnum::Value() const {
|
|
return (Ifc4::IfcConstructionProductResourceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcControllerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[204]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcControllerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[204]); }
|
|
|
|
/*
|
|
Ifc4::IfcControllerTypeEnum::IfcControllerTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcControllerTypeEnum::IfcControllerTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcControllerTypeEnum::IfcControllerTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcControllerTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcControllerTypeEnum::IfcControllerTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcControllerTypeEnum::Value Ifc4::IfcControllerTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcControllerTypeEnum::Value) Ifc4::IfcControllerTypeEnum::IfcControllerTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcControllerTypeEnum::operator Ifc4::IfcControllerTypeEnum::Value() const {
|
|
return (Ifc4::IfcControllerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcCooledBeamTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[209]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcCooledBeamTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[209]); }
|
|
|
|
/*
|
|
Ifc4::IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcCooledBeamTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcCooledBeamTypeEnum::Value Ifc4::IfcCooledBeamTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcCooledBeamTypeEnum::Value) Ifc4::IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcCooledBeamTypeEnum::operator Ifc4::IfcCooledBeamTypeEnum::Value() const {
|
|
return (Ifc4::IfcCooledBeamTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcCoolingTowerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[212]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcCoolingTowerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[212]); }
|
|
|
|
/*
|
|
Ifc4::IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcCoolingTowerTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcCoolingTowerTypeEnum::Value Ifc4::IfcCoolingTowerTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcCoolingTowerTypeEnum::Value) Ifc4::IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcCoolingTowerTypeEnum::operator Ifc4::IfcCoolingTowerTypeEnum::Value() const {
|
|
return (Ifc4::IfcCoolingTowerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcCostItemTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[217]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcCostItemTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[217]); }
|
|
|
|
/*
|
|
Ifc4::IfcCostItemTypeEnum::IfcCostItemTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcCostItemTypeEnum::IfcCostItemTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcCostItemTypeEnum::IfcCostItemTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcCostItemTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcCostItemTypeEnum::IfcCostItemTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcCostItemTypeEnum::Value Ifc4::IfcCostItemTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcCostItemTypeEnum::Value) Ifc4::IfcCostItemTypeEnum::IfcCostItemTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcCostItemTypeEnum::operator Ifc4::IfcCostItemTypeEnum::Value() const {
|
|
return (Ifc4::IfcCostItemTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcCostScheduleTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[219]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcCostScheduleTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[219]); }
|
|
|
|
/*
|
|
Ifc4::IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcCostScheduleTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcCostScheduleTypeEnum::Value Ifc4::IfcCostScheduleTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcCostScheduleTypeEnum::Value) Ifc4::IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcCostScheduleTypeEnum::operator Ifc4::IfcCostScheduleTypeEnum::Value() const {
|
|
return (Ifc4::IfcCostScheduleTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcCoveringTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[224]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcCoveringTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[224]); }
|
|
|
|
/*
|
|
Ifc4::IfcCoveringTypeEnum::IfcCoveringTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcCoveringTypeEnum::IfcCoveringTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcCoveringTypeEnum::IfcCoveringTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcCoveringTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcCoveringTypeEnum::IfcCoveringTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcCoveringTypeEnum::Value Ifc4::IfcCoveringTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcCoveringTypeEnum::Value) Ifc4::IfcCoveringTypeEnum::IfcCoveringTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcCoveringTypeEnum::operator Ifc4::IfcCoveringTypeEnum::Value() const {
|
|
return (Ifc4::IfcCoveringTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcCrewResourceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[227]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcCrewResourceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[227]); }
|
|
|
|
/*
|
|
Ifc4::IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcCrewResourceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcCrewResourceTypeEnum::Value Ifc4::IfcCrewResourceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcCrewResourceTypeEnum::Value) Ifc4::IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcCrewResourceTypeEnum::operator Ifc4::IfcCrewResourceTypeEnum::Value() const {
|
|
return (Ifc4::IfcCrewResourceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcCurtainWallTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[235]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcCurtainWallTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[235]); }
|
|
|
|
/*
|
|
Ifc4::IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcCurtainWallTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcCurtainWallTypeEnum::Value Ifc4::IfcCurtainWallTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcCurtainWallTypeEnum::Value) Ifc4::IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcCurtainWallTypeEnum::operator Ifc4::IfcCurtainWallTypeEnum::Value() const {
|
|
return (Ifc4::IfcCurtainWallTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcCurveInterpolationEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[241]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcCurveInterpolationEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[241]); }
|
|
|
|
/*
|
|
Ifc4::IfcCurveInterpolationEnum::IfcCurveInterpolationEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcCurveInterpolationEnum::IfcCurveInterpolationEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcCurveInterpolationEnum::IfcCurveInterpolationEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcCurveInterpolationEnum::ToString(Value v) {
|
|
return Ifc4::IfcCurveInterpolationEnum::IfcCurveInterpolationEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcCurveInterpolationEnum::Value Ifc4::IfcCurveInterpolationEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcCurveInterpolationEnum::Value) Ifc4::IfcCurveInterpolationEnum::IfcCurveInterpolationEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcCurveInterpolationEnum::operator Ifc4::IfcCurveInterpolationEnum::Value() const {
|
|
return (Ifc4::IfcCurveInterpolationEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDamperTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[252]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDamperTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[252]); }
|
|
|
|
/*
|
|
Ifc4::IfcDamperTypeEnum::IfcDamperTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDamperTypeEnum::IfcDamperTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDamperTypeEnum::IfcDamperTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDamperTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcDamperTypeEnum::IfcDamperTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDamperTypeEnum::Value Ifc4::IfcDamperTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDamperTypeEnum::Value) Ifc4::IfcDamperTypeEnum::IfcDamperTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDamperTypeEnum::operator Ifc4::IfcDamperTypeEnum::Value() const {
|
|
return (Ifc4::IfcDamperTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDataOriginEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[253]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDataOriginEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[253]); }
|
|
|
|
/*
|
|
Ifc4::IfcDataOriginEnum::IfcDataOriginEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDataOriginEnum::IfcDataOriginEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDataOriginEnum::IfcDataOriginEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDataOriginEnum::ToString(Value v) {
|
|
return Ifc4::IfcDataOriginEnum::IfcDataOriginEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDataOriginEnum::Value Ifc4::IfcDataOriginEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDataOriginEnum::Value) Ifc4::IfcDataOriginEnum::IfcDataOriginEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDataOriginEnum::operator Ifc4::IfcDataOriginEnum::Value() const {
|
|
return (Ifc4::IfcDataOriginEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDerivedUnitEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[263]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDerivedUnitEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[263]); }
|
|
|
|
/*
|
|
Ifc4::IfcDerivedUnitEnum::IfcDerivedUnitEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDerivedUnitEnum::IfcDerivedUnitEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDerivedUnitEnum::IfcDerivedUnitEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDerivedUnitEnum::ToString(Value v) {
|
|
return Ifc4::IfcDerivedUnitEnum::IfcDerivedUnitEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDerivedUnitEnum::Value Ifc4::IfcDerivedUnitEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDerivedUnitEnum::Value) Ifc4::IfcDerivedUnitEnum::IfcDerivedUnitEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDerivedUnitEnum::operator Ifc4::IfcDerivedUnitEnum::Value() const {
|
|
return (Ifc4::IfcDerivedUnitEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDirectionSenseEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[268]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDirectionSenseEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[268]); }
|
|
|
|
/*
|
|
Ifc4::IfcDirectionSenseEnum::IfcDirectionSenseEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDirectionSenseEnum::IfcDirectionSenseEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDirectionSenseEnum::IfcDirectionSenseEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDirectionSenseEnum::ToString(Value v) {
|
|
return Ifc4::IfcDirectionSenseEnum::IfcDirectionSenseEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDirectionSenseEnum::Value Ifc4::IfcDirectionSenseEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDirectionSenseEnum::Value) Ifc4::IfcDirectionSenseEnum::IfcDirectionSenseEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDirectionSenseEnum::operator Ifc4::IfcDirectionSenseEnum::Value() const {
|
|
return (Ifc4::IfcDirectionSenseEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDiscreteAccessoryTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[271]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDiscreteAccessoryTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[271]); }
|
|
|
|
/*
|
|
Ifc4::IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDiscreteAccessoryTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDiscreteAccessoryTypeEnum::Value Ifc4::IfcDiscreteAccessoryTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDiscreteAccessoryTypeEnum::Value) Ifc4::IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDiscreteAccessoryTypeEnum::operator Ifc4::IfcDiscreteAccessoryTypeEnum::Value() const {
|
|
return (Ifc4::IfcDiscreteAccessoryTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDistributionChamberElementTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[274]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDistributionChamberElementTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[274]); }
|
|
|
|
/*
|
|
Ifc4::IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDistributionChamberElementTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDistributionChamberElementTypeEnum::Value Ifc4::IfcDistributionChamberElementTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDistributionChamberElementTypeEnum::Value) Ifc4::IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDistributionChamberElementTypeEnum::operator Ifc4::IfcDistributionChamberElementTypeEnum::Value() const {
|
|
return (Ifc4::IfcDistributionChamberElementTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDistributionPortTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[283]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDistributionPortTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[283]); }
|
|
|
|
/*
|
|
Ifc4::IfcDistributionPortTypeEnum::IfcDistributionPortTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDistributionPortTypeEnum::IfcDistributionPortTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDistributionPortTypeEnum::IfcDistributionPortTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDistributionPortTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcDistributionPortTypeEnum::IfcDistributionPortTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDistributionPortTypeEnum::Value Ifc4::IfcDistributionPortTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDistributionPortTypeEnum::Value) Ifc4::IfcDistributionPortTypeEnum::IfcDistributionPortTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDistributionPortTypeEnum::operator Ifc4::IfcDistributionPortTypeEnum::Value() const {
|
|
return (Ifc4::IfcDistributionPortTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDistributionSystemEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[285]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDistributionSystemEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[285]); }
|
|
|
|
/*
|
|
Ifc4::IfcDistributionSystemEnum::IfcDistributionSystemEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDistributionSystemEnum::IfcDistributionSystemEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDistributionSystemEnum::IfcDistributionSystemEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDistributionSystemEnum::ToString(Value v) {
|
|
return Ifc4::IfcDistributionSystemEnum::IfcDistributionSystemEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDistributionSystemEnum::Value Ifc4::IfcDistributionSystemEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDistributionSystemEnum::Value) Ifc4::IfcDistributionSystemEnum::IfcDistributionSystemEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDistributionSystemEnum::operator Ifc4::IfcDistributionSystemEnum::Value() const {
|
|
return (Ifc4::IfcDistributionSystemEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDocumentConfidentialityEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[286]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDocumentConfidentialityEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[286]); }
|
|
|
|
/*
|
|
Ifc4::IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDocumentConfidentialityEnum::ToString(Value v) {
|
|
return Ifc4::IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDocumentConfidentialityEnum::Value Ifc4::IfcDocumentConfidentialityEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDocumentConfidentialityEnum::Value) Ifc4::IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDocumentConfidentialityEnum::operator Ifc4::IfcDocumentConfidentialityEnum::Value() const {
|
|
return (Ifc4::IfcDocumentConfidentialityEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDocumentStatusEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[291]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDocumentStatusEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[291]); }
|
|
|
|
/*
|
|
Ifc4::IfcDocumentStatusEnum::IfcDocumentStatusEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDocumentStatusEnum::IfcDocumentStatusEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDocumentStatusEnum::IfcDocumentStatusEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDocumentStatusEnum::ToString(Value v) {
|
|
return Ifc4::IfcDocumentStatusEnum::IfcDocumentStatusEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDocumentStatusEnum::Value Ifc4::IfcDocumentStatusEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDocumentStatusEnum::Value) Ifc4::IfcDocumentStatusEnum::IfcDocumentStatusEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDocumentStatusEnum::operator Ifc4::IfcDocumentStatusEnum::Value() const {
|
|
return (Ifc4::IfcDocumentStatusEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDoorPanelOperationEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[294]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDoorPanelOperationEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[294]); }
|
|
|
|
/*
|
|
Ifc4::IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDoorPanelOperationEnum::ToString(Value v) {
|
|
return Ifc4::IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDoorPanelOperationEnum::Value Ifc4::IfcDoorPanelOperationEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDoorPanelOperationEnum::Value) Ifc4::IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDoorPanelOperationEnum::operator Ifc4::IfcDoorPanelOperationEnum::Value() const {
|
|
return (Ifc4::IfcDoorPanelOperationEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDoorPanelPositionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[295]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDoorPanelPositionEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[295]); }
|
|
|
|
/*
|
|
Ifc4::IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDoorPanelPositionEnum::ToString(Value v) {
|
|
return Ifc4::IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDoorPanelPositionEnum::Value Ifc4::IfcDoorPanelPositionEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDoorPanelPositionEnum::Value) Ifc4::IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDoorPanelPositionEnum::operator Ifc4::IfcDoorPanelPositionEnum::Value() const {
|
|
return (Ifc4::IfcDoorPanelPositionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDoorStyleConstructionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[299]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDoorStyleConstructionEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[299]); }
|
|
|
|
/*
|
|
Ifc4::IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDoorStyleConstructionEnum::ToString(Value v) {
|
|
return Ifc4::IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDoorStyleConstructionEnum::Value Ifc4::IfcDoorStyleConstructionEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDoorStyleConstructionEnum::Value) Ifc4::IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDoorStyleConstructionEnum::operator Ifc4::IfcDoorStyleConstructionEnum::Value() const {
|
|
return (Ifc4::IfcDoorStyleConstructionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDoorStyleOperationEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[300]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDoorStyleOperationEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[300]); }
|
|
|
|
/*
|
|
Ifc4::IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDoorStyleOperationEnum::ToString(Value v) {
|
|
return Ifc4::IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDoorStyleOperationEnum::Value Ifc4::IfcDoorStyleOperationEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDoorStyleOperationEnum::Value) Ifc4::IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDoorStyleOperationEnum::operator Ifc4::IfcDoorStyleOperationEnum::Value() const {
|
|
return (Ifc4::IfcDoorStyleOperationEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDoorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[302]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDoorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[302]); }
|
|
|
|
/*
|
|
Ifc4::IfcDoorTypeEnum::IfcDoorTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDoorTypeEnum::IfcDoorTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDoorTypeEnum::IfcDoorTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDoorTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcDoorTypeEnum::IfcDoorTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDoorTypeEnum::Value Ifc4::IfcDoorTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDoorTypeEnum::Value) Ifc4::IfcDoorTypeEnum::IfcDoorTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDoorTypeEnum::operator Ifc4::IfcDoorTypeEnum::Value() const {
|
|
return (Ifc4::IfcDoorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDoorTypeOperationEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[303]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDoorTypeOperationEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[303]); }
|
|
|
|
/*
|
|
Ifc4::IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDoorTypeOperationEnum::ToString(Value v) {
|
|
return Ifc4::IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDoorTypeOperationEnum::Value Ifc4::IfcDoorTypeOperationEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDoorTypeOperationEnum::Value) Ifc4::IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDoorTypeOperationEnum::operator Ifc4::IfcDoorTypeOperationEnum::Value() const {
|
|
return (Ifc4::IfcDoorTypeOperationEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDuctFittingTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[309]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDuctFittingTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[309]); }
|
|
|
|
/*
|
|
Ifc4::IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDuctFittingTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDuctFittingTypeEnum::Value Ifc4::IfcDuctFittingTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDuctFittingTypeEnum::Value) Ifc4::IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDuctFittingTypeEnum::operator Ifc4::IfcDuctFittingTypeEnum::Value() const {
|
|
return (Ifc4::IfcDuctFittingTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDuctSegmentTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[312]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDuctSegmentTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[312]); }
|
|
|
|
/*
|
|
Ifc4::IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDuctSegmentTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDuctSegmentTypeEnum::Value Ifc4::IfcDuctSegmentTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDuctSegmentTypeEnum::Value) Ifc4::IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDuctSegmentTypeEnum::operator Ifc4::IfcDuctSegmentTypeEnum::Value() const {
|
|
return (Ifc4::IfcDuctSegmentTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcDuctSilencerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[315]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcDuctSilencerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[315]); }
|
|
|
|
/*
|
|
Ifc4::IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcDuctSilencerTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcDuctSilencerTypeEnum::Value Ifc4::IfcDuctSilencerTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcDuctSilencerTypeEnum::Value) Ifc4::IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcDuctSilencerTypeEnum::operator Ifc4::IfcDuctSilencerTypeEnum::Value() const {
|
|
return (Ifc4::IfcDuctSilencerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcElectricApplianceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[323]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcElectricApplianceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[323]); }
|
|
|
|
/*
|
|
Ifc4::IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcElectricApplianceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcElectricApplianceTypeEnum::Value Ifc4::IfcElectricApplianceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcElectricApplianceTypeEnum::Value) Ifc4::IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcElectricApplianceTypeEnum::operator Ifc4::IfcElectricApplianceTypeEnum::Value() const {
|
|
return (Ifc4::IfcElectricApplianceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcElectricDistributionBoardTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[330]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcElectricDistributionBoardTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[330]); }
|
|
|
|
/*
|
|
Ifc4::IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcElectricDistributionBoardTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcElectricDistributionBoardTypeEnum::Value Ifc4::IfcElectricDistributionBoardTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcElectricDistributionBoardTypeEnum::Value) Ifc4::IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcElectricDistributionBoardTypeEnum::operator Ifc4::IfcElectricDistributionBoardTypeEnum::Value() const {
|
|
return (Ifc4::IfcElectricDistributionBoardTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcElectricFlowStorageDeviceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[333]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcElectricFlowStorageDeviceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[333]); }
|
|
|
|
/*
|
|
Ifc4::IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcElectricFlowStorageDeviceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcElectricFlowStorageDeviceTypeEnum::Value Ifc4::IfcElectricFlowStorageDeviceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcElectricFlowStorageDeviceTypeEnum::Value) Ifc4::IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcElectricFlowStorageDeviceTypeEnum::operator Ifc4::IfcElectricFlowStorageDeviceTypeEnum::Value() const {
|
|
return (Ifc4::IfcElectricFlowStorageDeviceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcElectricGeneratorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[336]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcElectricGeneratorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[336]); }
|
|
|
|
/*
|
|
Ifc4::IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcElectricGeneratorTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcElectricGeneratorTypeEnum::Value Ifc4::IfcElectricGeneratorTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcElectricGeneratorTypeEnum::Value) Ifc4::IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcElectricGeneratorTypeEnum::operator Ifc4::IfcElectricGeneratorTypeEnum::Value() const {
|
|
return (Ifc4::IfcElectricGeneratorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcElectricMotorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[339]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcElectricMotorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[339]); }
|
|
|
|
/*
|
|
Ifc4::IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcElectricMotorTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcElectricMotorTypeEnum::Value Ifc4::IfcElectricMotorTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcElectricMotorTypeEnum::Value) Ifc4::IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcElectricMotorTypeEnum::operator Ifc4::IfcElectricMotorTypeEnum::Value() const {
|
|
return (Ifc4::IfcElectricMotorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcElectricTimeControlTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[343]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcElectricTimeControlTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[343]); }
|
|
|
|
/*
|
|
Ifc4::IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcElectricTimeControlTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcElectricTimeControlTypeEnum::Value Ifc4::IfcElectricTimeControlTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcElectricTimeControlTypeEnum::Value) Ifc4::IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcElectricTimeControlTypeEnum::operator Ifc4::IfcElectricTimeControlTypeEnum::Value() const {
|
|
return (Ifc4::IfcElectricTimeControlTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcElementAssemblyTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[349]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcElementAssemblyTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[349]); }
|
|
|
|
/*
|
|
Ifc4::IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcElementAssemblyTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcElementAssemblyTypeEnum::Value Ifc4::IfcElementAssemblyTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcElementAssemblyTypeEnum::Value) Ifc4::IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcElementAssemblyTypeEnum::operator Ifc4::IfcElementAssemblyTypeEnum::Value() const {
|
|
return (Ifc4::IfcElementAssemblyTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcElementCompositionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[352]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcElementCompositionEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[352]); }
|
|
|
|
/*
|
|
Ifc4::IfcElementCompositionEnum::IfcElementCompositionEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcElementCompositionEnum::IfcElementCompositionEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcElementCompositionEnum::IfcElementCompositionEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcElementCompositionEnum::ToString(Value v) {
|
|
return Ifc4::IfcElementCompositionEnum::IfcElementCompositionEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcElementCompositionEnum::Value Ifc4::IfcElementCompositionEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcElementCompositionEnum::Value) Ifc4::IfcElementCompositionEnum::IfcElementCompositionEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcElementCompositionEnum::operator Ifc4::IfcElementCompositionEnum::Value() const {
|
|
return (Ifc4::IfcElementCompositionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcEngineTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[362]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcEngineTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[362]); }
|
|
|
|
/*
|
|
Ifc4::IfcEngineTypeEnum::IfcEngineTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcEngineTypeEnum::IfcEngineTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcEngineTypeEnum::IfcEngineTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcEngineTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcEngineTypeEnum::IfcEngineTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcEngineTypeEnum::Value Ifc4::IfcEngineTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcEngineTypeEnum::Value) Ifc4::IfcEngineTypeEnum::IfcEngineTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcEngineTypeEnum::operator Ifc4::IfcEngineTypeEnum::Value() const {
|
|
return (Ifc4::IfcEngineTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcEvaporativeCoolerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[365]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcEvaporativeCoolerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[365]); }
|
|
|
|
/*
|
|
Ifc4::IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcEvaporativeCoolerTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcEvaporativeCoolerTypeEnum::Value Ifc4::IfcEvaporativeCoolerTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcEvaporativeCoolerTypeEnum::Value) Ifc4::IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcEvaporativeCoolerTypeEnum::operator Ifc4::IfcEvaporativeCoolerTypeEnum::Value() const {
|
|
return (Ifc4::IfcEvaporativeCoolerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcEvaporatorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[368]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcEvaporatorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[368]); }
|
|
|
|
/*
|
|
Ifc4::IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcEvaporatorTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcEvaporatorTypeEnum::Value Ifc4::IfcEvaporatorTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcEvaporatorTypeEnum::Value) Ifc4::IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcEvaporatorTypeEnum::operator Ifc4::IfcEvaporatorTypeEnum::Value() const {
|
|
return (Ifc4::IfcEvaporatorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcEventTriggerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[371]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcEventTriggerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[371]); }
|
|
|
|
/*
|
|
Ifc4::IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcEventTriggerTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcEventTriggerTypeEnum::Value Ifc4::IfcEventTriggerTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcEventTriggerTypeEnum::Value) Ifc4::IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcEventTriggerTypeEnum::operator Ifc4::IfcEventTriggerTypeEnum::Value() const {
|
|
return (Ifc4::IfcEventTriggerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcEventTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[373]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcEventTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[373]); }
|
|
|
|
/*
|
|
Ifc4::IfcEventTypeEnum::IfcEventTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcEventTypeEnum::IfcEventTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcEventTypeEnum::IfcEventTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcEventTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcEventTypeEnum::IfcEventTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcEventTypeEnum::Value Ifc4::IfcEventTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcEventTypeEnum::Value) Ifc4::IfcEventTypeEnum::IfcEventTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcEventTypeEnum::operator Ifc4::IfcEventTypeEnum::Value() const {
|
|
return (Ifc4::IfcEventTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcExternalSpatialElementTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[382]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcExternalSpatialElementTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[382]); }
|
|
|
|
/*
|
|
Ifc4::IfcExternalSpatialElementTypeEnum::IfcExternalSpatialElementTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcExternalSpatialElementTypeEnum::IfcExternalSpatialElementTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcExternalSpatialElementTypeEnum::IfcExternalSpatialElementTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcExternalSpatialElementTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcExternalSpatialElementTypeEnum::IfcExternalSpatialElementTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcExternalSpatialElementTypeEnum::Value Ifc4::IfcExternalSpatialElementTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcExternalSpatialElementTypeEnum::Value) Ifc4::IfcExternalSpatialElementTypeEnum::IfcExternalSpatialElementTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcExternalSpatialElementTypeEnum::operator Ifc4::IfcExternalSpatialElementTypeEnum::Value() const {
|
|
return (Ifc4::IfcExternalSpatialElementTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcFanTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[396]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcFanTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[396]); }
|
|
|
|
/*
|
|
Ifc4::IfcFanTypeEnum::IfcFanTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcFanTypeEnum::IfcFanTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcFanTypeEnum::IfcFanTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcFanTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcFanTypeEnum::IfcFanTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcFanTypeEnum::Value Ifc4::IfcFanTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcFanTypeEnum::Value) Ifc4::IfcFanTypeEnum::IfcFanTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcFanTypeEnum::operator Ifc4::IfcFanTypeEnum::Value() const {
|
|
return (Ifc4::IfcFanTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcFastenerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[399]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcFastenerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[399]); }
|
|
|
|
/*
|
|
Ifc4::IfcFastenerTypeEnum::IfcFastenerTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcFastenerTypeEnum::IfcFastenerTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcFastenerTypeEnum::IfcFastenerTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcFastenerTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcFastenerTypeEnum::IfcFastenerTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcFastenerTypeEnum::Value Ifc4::IfcFastenerTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcFastenerTypeEnum::Value) Ifc4::IfcFastenerTypeEnum::IfcFastenerTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcFastenerTypeEnum::operator Ifc4::IfcFastenerTypeEnum::Value() const {
|
|
return (Ifc4::IfcFastenerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcFilterTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[409]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcFilterTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[409]); }
|
|
|
|
/*
|
|
Ifc4::IfcFilterTypeEnum::IfcFilterTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcFilterTypeEnum::IfcFilterTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcFilterTypeEnum::IfcFilterTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcFilterTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcFilterTypeEnum::IfcFilterTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcFilterTypeEnum::Value Ifc4::IfcFilterTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcFilterTypeEnum::Value) Ifc4::IfcFilterTypeEnum::IfcFilterTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcFilterTypeEnum::operator Ifc4::IfcFilterTypeEnum::Value() const {
|
|
return (Ifc4::IfcFilterTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcFireSuppressionTerminalTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[412]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcFireSuppressionTerminalTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[412]); }
|
|
|
|
/*
|
|
Ifc4::IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcFireSuppressionTerminalTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcFireSuppressionTerminalTypeEnum::Value Ifc4::IfcFireSuppressionTerminalTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcFireSuppressionTerminalTypeEnum::Value) Ifc4::IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcFireSuppressionTerminalTypeEnum::operator Ifc4::IfcFireSuppressionTerminalTypeEnum::Value() const {
|
|
return (Ifc4::IfcFireSuppressionTerminalTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcFlowDirectionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[416]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcFlowDirectionEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[416]); }
|
|
|
|
/*
|
|
Ifc4::IfcFlowDirectionEnum::IfcFlowDirectionEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcFlowDirectionEnum::IfcFlowDirectionEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcFlowDirectionEnum::IfcFlowDirectionEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcFlowDirectionEnum::ToString(Value v) {
|
|
return Ifc4::IfcFlowDirectionEnum::IfcFlowDirectionEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcFlowDirectionEnum::Value Ifc4::IfcFlowDirectionEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcFlowDirectionEnum::Value) Ifc4::IfcFlowDirectionEnum::IfcFlowDirectionEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcFlowDirectionEnum::operator Ifc4::IfcFlowDirectionEnum::Value() const {
|
|
return (Ifc4::IfcFlowDirectionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcFlowInstrumentTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[421]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcFlowInstrumentTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[421]); }
|
|
|
|
/*
|
|
Ifc4::IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcFlowInstrumentTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcFlowInstrumentTypeEnum::Value Ifc4::IfcFlowInstrumentTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcFlowInstrumentTypeEnum::Value) Ifc4::IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcFlowInstrumentTypeEnum::operator Ifc4::IfcFlowInstrumentTypeEnum::Value() const {
|
|
return (Ifc4::IfcFlowInstrumentTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcFlowMeterTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[424]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcFlowMeterTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[424]); }
|
|
|
|
/*
|
|
Ifc4::IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcFlowMeterTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcFlowMeterTypeEnum::Value Ifc4::IfcFlowMeterTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcFlowMeterTypeEnum::Value) Ifc4::IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcFlowMeterTypeEnum::operator Ifc4::IfcFlowMeterTypeEnum::Value() const {
|
|
return (Ifc4::IfcFlowMeterTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcFootingTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[440]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcFootingTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[440]); }
|
|
|
|
/*
|
|
Ifc4::IfcFootingTypeEnum::IfcFootingTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcFootingTypeEnum::IfcFootingTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcFootingTypeEnum::IfcFootingTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcFootingTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcFootingTypeEnum::IfcFootingTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcFootingTypeEnum::Value Ifc4::IfcFootingTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcFootingTypeEnum::Value) Ifc4::IfcFootingTypeEnum::IfcFootingTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcFootingTypeEnum::operator Ifc4::IfcFootingTypeEnum::Value() const {
|
|
return (Ifc4::IfcFootingTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcFurnitureTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[447]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcFurnitureTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[447]); }
|
|
|
|
/*
|
|
Ifc4::IfcFurnitureTypeEnum::IfcFurnitureTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcFurnitureTypeEnum::IfcFurnitureTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcFurnitureTypeEnum::IfcFurnitureTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcFurnitureTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcFurnitureTypeEnum::IfcFurnitureTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcFurnitureTypeEnum::Value Ifc4::IfcFurnitureTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcFurnitureTypeEnum::Value) Ifc4::IfcFurnitureTypeEnum::IfcFurnitureTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcFurnitureTypeEnum::operator Ifc4::IfcFurnitureTypeEnum::Value() const {
|
|
return (Ifc4::IfcFurnitureTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcGeographicElementTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[450]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcGeographicElementTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[450]); }
|
|
|
|
/*
|
|
Ifc4::IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcGeographicElementTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcGeographicElementTypeEnum::Value Ifc4::IfcGeographicElementTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcGeographicElementTypeEnum::Value) Ifc4::IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcGeographicElementTypeEnum::operator Ifc4::IfcGeographicElementTypeEnum::Value() const {
|
|
return (Ifc4::IfcGeographicElementTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcGeometricProjectionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[452]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcGeometricProjectionEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[452]); }
|
|
|
|
/*
|
|
Ifc4::IfcGeometricProjectionEnum::IfcGeometricProjectionEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcGeometricProjectionEnum::IfcGeometricProjectionEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcGeometricProjectionEnum::IfcGeometricProjectionEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcGeometricProjectionEnum::ToString(Value v) {
|
|
return Ifc4::IfcGeometricProjectionEnum::IfcGeometricProjectionEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcGeometricProjectionEnum::Value Ifc4::IfcGeometricProjectionEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcGeometricProjectionEnum::Value) Ifc4::IfcGeometricProjectionEnum::IfcGeometricProjectionEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcGeometricProjectionEnum::operator Ifc4::IfcGeometricProjectionEnum::Value() const {
|
|
return (Ifc4::IfcGeometricProjectionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcGlobalOrLocalEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[459]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcGlobalOrLocalEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[459]); }
|
|
|
|
/*
|
|
Ifc4::IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcGlobalOrLocalEnum::ToString(Value v) {
|
|
return Ifc4::IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcGlobalOrLocalEnum::Value Ifc4::IfcGlobalOrLocalEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcGlobalOrLocalEnum::Value) Ifc4::IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcGlobalOrLocalEnum::operator Ifc4::IfcGlobalOrLocalEnum::Value() const {
|
|
return (Ifc4::IfcGlobalOrLocalEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcGridTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[464]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcGridTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[464]); }
|
|
|
|
/*
|
|
Ifc4::IfcGridTypeEnum::IfcGridTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcGridTypeEnum::IfcGridTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcGridTypeEnum::IfcGridTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcGridTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcGridTypeEnum::IfcGridTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcGridTypeEnum::Value Ifc4::IfcGridTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcGridTypeEnum::Value) Ifc4::IfcGridTypeEnum::IfcGridTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcGridTypeEnum::operator Ifc4::IfcGridTypeEnum::Value() const {
|
|
return (Ifc4::IfcGridTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcHeatExchangerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[470]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcHeatExchangerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[470]); }
|
|
|
|
/*
|
|
Ifc4::IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcHeatExchangerTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcHeatExchangerTypeEnum::Value Ifc4::IfcHeatExchangerTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcHeatExchangerTypeEnum::Value) Ifc4::IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcHeatExchangerTypeEnum::operator Ifc4::IfcHeatExchangerTypeEnum::Value() const {
|
|
return (Ifc4::IfcHeatExchangerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcHumidifierTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[475]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcHumidifierTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[475]); }
|
|
|
|
/*
|
|
Ifc4::IfcHumidifierTypeEnum::IfcHumidifierTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcHumidifierTypeEnum::IfcHumidifierTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcHumidifierTypeEnum::IfcHumidifierTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcHumidifierTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcHumidifierTypeEnum::IfcHumidifierTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcHumidifierTypeEnum::Value Ifc4::IfcHumidifierTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcHumidifierTypeEnum::Value) Ifc4::IfcHumidifierTypeEnum::IfcHumidifierTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcHumidifierTypeEnum::operator Ifc4::IfcHumidifierTypeEnum::Value() const {
|
|
return (Ifc4::IfcHumidifierTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcInterceptorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[490]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcInterceptorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[490]); }
|
|
|
|
/*
|
|
Ifc4::IfcInterceptorTypeEnum::IfcInterceptorTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcInterceptorTypeEnum::IfcInterceptorTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcInterceptorTypeEnum::IfcInterceptorTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcInterceptorTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcInterceptorTypeEnum::IfcInterceptorTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcInterceptorTypeEnum::Value Ifc4::IfcInterceptorTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcInterceptorTypeEnum::Value) Ifc4::IfcInterceptorTypeEnum::IfcInterceptorTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcInterceptorTypeEnum::operator Ifc4::IfcInterceptorTypeEnum::Value() const {
|
|
return (Ifc4::IfcInterceptorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcInternalOrExternalEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[491]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcInternalOrExternalEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[491]); }
|
|
|
|
/*
|
|
Ifc4::IfcInternalOrExternalEnum::IfcInternalOrExternalEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcInternalOrExternalEnum::IfcInternalOrExternalEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcInternalOrExternalEnum::IfcInternalOrExternalEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcInternalOrExternalEnum::ToString(Value v) {
|
|
return Ifc4::IfcInternalOrExternalEnum::IfcInternalOrExternalEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcInternalOrExternalEnum::Value Ifc4::IfcInternalOrExternalEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcInternalOrExternalEnum::Value) Ifc4::IfcInternalOrExternalEnum::IfcInternalOrExternalEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcInternalOrExternalEnum::operator Ifc4::IfcInternalOrExternalEnum::Value() const {
|
|
return (Ifc4::IfcInternalOrExternalEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcInventoryTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[494]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcInventoryTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[494]); }
|
|
|
|
/*
|
|
Ifc4::IfcInventoryTypeEnum::IfcInventoryTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcInventoryTypeEnum::IfcInventoryTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcInventoryTypeEnum::IfcInventoryTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcInventoryTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcInventoryTypeEnum::IfcInventoryTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcInventoryTypeEnum::Value Ifc4::IfcInventoryTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcInventoryTypeEnum::Value) Ifc4::IfcInventoryTypeEnum::IfcInventoryTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcInventoryTypeEnum::operator Ifc4::IfcInventoryTypeEnum::Value() const {
|
|
return (Ifc4::IfcInventoryTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcJunctionBoxTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[502]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcJunctionBoxTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[502]); }
|
|
|
|
/*
|
|
Ifc4::IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcJunctionBoxTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcJunctionBoxTypeEnum::Value Ifc4::IfcJunctionBoxTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcJunctionBoxTypeEnum::Value) Ifc4::IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcJunctionBoxTypeEnum::operator Ifc4::IfcJunctionBoxTypeEnum::Value() const {
|
|
return (Ifc4::IfcJunctionBoxTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcKnotType::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[504]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcKnotType::Class() { return *((IfcParse::enumeration_type*)IFC4_types[504]); }
|
|
|
|
/*
|
|
Ifc4::IfcKnotType::IfcKnotType(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcKnotType::IfcKnotType(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcKnotType::IfcKnotType(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcKnotType::ToString(Value v) {
|
|
return Ifc4::IfcKnotType::IfcKnotType::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcKnotType::Value Ifc4::IfcKnotType::FromString(const std::string& s) {
|
|
return (Ifc4::IfcKnotType::Value) Ifc4::IfcKnotType::IfcKnotType::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcKnotType::operator Ifc4::IfcKnotType::Value() const {
|
|
return (Ifc4::IfcKnotType::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcLaborResourceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[508]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcLaborResourceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[508]); }
|
|
|
|
/*
|
|
Ifc4::IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcLaborResourceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcLaborResourceTypeEnum::Value Ifc4::IfcLaborResourceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcLaborResourceTypeEnum::Value) Ifc4::IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcLaborResourceTypeEnum::operator Ifc4::IfcLaborResourceTypeEnum::Value() const {
|
|
return (Ifc4::IfcLaborResourceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcLampTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[512]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcLampTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[512]); }
|
|
|
|
/*
|
|
Ifc4::IfcLampTypeEnum::IfcLampTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcLampTypeEnum::IfcLampTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcLampTypeEnum::IfcLampTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcLampTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcLampTypeEnum::IfcLampTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcLampTypeEnum::Value Ifc4::IfcLampTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcLampTypeEnum::Value) Ifc4::IfcLampTypeEnum::IfcLampTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcLampTypeEnum::operator Ifc4::IfcLampTypeEnum::Value() const {
|
|
return (Ifc4::IfcLampTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcLayerSetDirectionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[515]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcLayerSetDirectionEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[515]); }
|
|
|
|
/*
|
|
Ifc4::IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcLayerSetDirectionEnum::ToString(Value v) {
|
|
return Ifc4::IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcLayerSetDirectionEnum::Value Ifc4::IfcLayerSetDirectionEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcLayerSetDirectionEnum::Value) Ifc4::IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcLayerSetDirectionEnum::operator Ifc4::IfcLayerSetDirectionEnum::Value() const {
|
|
return (Ifc4::IfcLayerSetDirectionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcLightDistributionCurveEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[520]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcLightDistributionCurveEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[520]); }
|
|
|
|
/*
|
|
Ifc4::IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcLightDistributionCurveEnum::ToString(Value v) {
|
|
return Ifc4::IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcLightDistributionCurveEnum::Value Ifc4::IfcLightDistributionCurveEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcLightDistributionCurveEnum::Value) Ifc4::IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcLightDistributionCurveEnum::operator Ifc4::IfcLightDistributionCurveEnum::Value() const {
|
|
return (Ifc4::IfcLightDistributionCurveEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcLightEmissionSourceEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[523]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcLightEmissionSourceEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[523]); }
|
|
|
|
/*
|
|
Ifc4::IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcLightEmissionSourceEnum::ToString(Value v) {
|
|
return Ifc4::IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcLightEmissionSourceEnum::Value Ifc4::IfcLightEmissionSourceEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcLightEmissionSourceEnum::Value) Ifc4::IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcLightEmissionSourceEnum::operator Ifc4::IfcLightEmissionSourceEnum::Value() const {
|
|
return (Ifc4::IfcLightEmissionSourceEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcLightFixtureTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[526]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcLightFixtureTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[526]); }
|
|
|
|
/*
|
|
Ifc4::IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcLightFixtureTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcLightFixtureTypeEnum::Value Ifc4::IfcLightFixtureTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcLightFixtureTypeEnum::Value) Ifc4::IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcLightFixtureTypeEnum::operator Ifc4::IfcLightFixtureTypeEnum::Value() const {
|
|
return (Ifc4::IfcLightFixtureTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcLoadGroupTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[540]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcLoadGroupTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[540]); }
|
|
|
|
/*
|
|
Ifc4::IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcLoadGroupTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcLoadGroupTypeEnum::Value Ifc4::IfcLoadGroupTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcLoadGroupTypeEnum::Value) Ifc4::IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcLoadGroupTypeEnum::operator Ifc4::IfcLoadGroupTypeEnum::Value() const {
|
|
return (Ifc4::IfcLoadGroupTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcLogicalOperatorEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[543]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcLogicalOperatorEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[543]); }
|
|
|
|
/*
|
|
Ifc4::IfcLogicalOperatorEnum::IfcLogicalOperatorEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcLogicalOperatorEnum::IfcLogicalOperatorEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcLogicalOperatorEnum::IfcLogicalOperatorEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcLogicalOperatorEnum::ToString(Value v) {
|
|
return Ifc4::IfcLogicalOperatorEnum::IfcLogicalOperatorEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcLogicalOperatorEnum::Value Ifc4::IfcLogicalOperatorEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcLogicalOperatorEnum::Value) Ifc4::IfcLogicalOperatorEnum::IfcLogicalOperatorEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcLogicalOperatorEnum::operator Ifc4::IfcLogicalOperatorEnum::Value() const {
|
|
return (Ifc4::IfcLogicalOperatorEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcMechanicalFastenerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[582]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcMechanicalFastenerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[582]); }
|
|
|
|
/*
|
|
Ifc4::IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcMechanicalFastenerTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcMechanicalFastenerTypeEnum::Value Ifc4::IfcMechanicalFastenerTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcMechanicalFastenerTypeEnum::Value) Ifc4::IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcMechanicalFastenerTypeEnum::operator Ifc4::IfcMechanicalFastenerTypeEnum::Value() const {
|
|
return (Ifc4::IfcMechanicalFastenerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcMedicalDeviceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[585]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcMedicalDeviceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[585]); }
|
|
|
|
/*
|
|
Ifc4::IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcMedicalDeviceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcMedicalDeviceTypeEnum::Value Ifc4::IfcMedicalDeviceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcMedicalDeviceTypeEnum::Value) Ifc4::IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcMedicalDeviceTypeEnum::operator Ifc4::IfcMedicalDeviceTypeEnum::Value() const {
|
|
return (Ifc4::IfcMedicalDeviceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcMemberTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[589]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcMemberTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[589]); }
|
|
|
|
/*
|
|
Ifc4::IfcMemberTypeEnum::IfcMemberTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcMemberTypeEnum::IfcMemberTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcMemberTypeEnum::IfcMemberTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcMemberTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcMemberTypeEnum::IfcMemberTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcMemberTypeEnum::Value Ifc4::IfcMemberTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcMemberTypeEnum::Value) Ifc4::IfcMemberTypeEnum::IfcMemberTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcMemberTypeEnum::operator Ifc4::IfcMemberTypeEnum::Value() const {
|
|
return (Ifc4::IfcMemberTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcMotorConnectionTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[608]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcMotorConnectionTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[608]); }
|
|
|
|
/*
|
|
Ifc4::IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcMotorConnectionTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcMotorConnectionTypeEnum::Value Ifc4::IfcMotorConnectionTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcMotorConnectionTypeEnum::Value) Ifc4::IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcMotorConnectionTypeEnum::operator Ifc4::IfcMotorConnectionTypeEnum::Value() const {
|
|
return (Ifc4::IfcMotorConnectionTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcNullStyle::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[612]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcNullStyle::Class() { return *((IfcParse::enumeration_type*)IFC4_types[612]); }
|
|
|
|
/*
|
|
Ifc4::IfcNullStyle::IfcNullStyle(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcNullStyle::IfcNullStyle(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcNullStyle::IfcNullStyle(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcNullStyle::ToString(Value v) {
|
|
return Ifc4::IfcNullStyle::IfcNullStyle::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcNullStyle::Value Ifc4::IfcNullStyle::FromString(const std::string& s) {
|
|
return (Ifc4::IfcNullStyle::Value) Ifc4::IfcNullStyle::IfcNullStyle::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcNullStyle::operator Ifc4::IfcNullStyle::Value() const {
|
|
return (Ifc4::IfcNullStyle::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcObjectTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[620]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcObjectTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[620]); }
|
|
|
|
/*
|
|
Ifc4::IfcObjectTypeEnum::IfcObjectTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcObjectTypeEnum::IfcObjectTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcObjectTypeEnum::IfcObjectTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcObjectTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcObjectTypeEnum::IfcObjectTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcObjectTypeEnum::Value Ifc4::IfcObjectTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcObjectTypeEnum::Value) Ifc4::IfcObjectTypeEnum::IfcObjectTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcObjectTypeEnum::operator Ifc4::IfcObjectTypeEnum::Value() const {
|
|
return (Ifc4::IfcObjectTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcObjectiveEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[617]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcObjectiveEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[617]); }
|
|
|
|
/*
|
|
Ifc4::IfcObjectiveEnum::IfcObjectiveEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcObjectiveEnum::IfcObjectiveEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcObjectiveEnum::IfcObjectiveEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcObjectiveEnum::ToString(Value v) {
|
|
return Ifc4::IfcObjectiveEnum::IfcObjectiveEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcObjectiveEnum::Value Ifc4::IfcObjectiveEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcObjectiveEnum::Value) Ifc4::IfcObjectiveEnum::IfcObjectiveEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcObjectiveEnum::operator Ifc4::IfcObjectiveEnum::Value() const {
|
|
return (Ifc4::IfcObjectiveEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcOccupantTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[622]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcOccupantTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[622]); }
|
|
|
|
/*
|
|
Ifc4::IfcOccupantTypeEnum::IfcOccupantTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcOccupantTypeEnum::IfcOccupantTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcOccupantTypeEnum::IfcOccupantTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcOccupantTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcOccupantTypeEnum::IfcOccupantTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcOccupantTypeEnum::Value Ifc4::IfcOccupantTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcOccupantTypeEnum::Value) Ifc4::IfcOccupantTypeEnum::IfcOccupantTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcOccupantTypeEnum::operator Ifc4::IfcOccupantTypeEnum::Value() const {
|
|
return (Ifc4::IfcOccupantTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcOpeningElementTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[626]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcOpeningElementTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[626]); }
|
|
|
|
/*
|
|
Ifc4::IfcOpeningElementTypeEnum::IfcOpeningElementTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcOpeningElementTypeEnum::IfcOpeningElementTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcOpeningElementTypeEnum::IfcOpeningElementTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcOpeningElementTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcOpeningElementTypeEnum::IfcOpeningElementTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcOpeningElementTypeEnum::Value Ifc4::IfcOpeningElementTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcOpeningElementTypeEnum::Value) Ifc4::IfcOpeningElementTypeEnum::IfcOpeningElementTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcOpeningElementTypeEnum::operator Ifc4::IfcOpeningElementTypeEnum::Value() const {
|
|
return (Ifc4::IfcOpeningElementTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcOutletTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[635]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcOutletTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[635]); }
|
|
|
|
/*
|
|
Ifc4::IfcOutletTypeEnum::IfcOutletTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcOutletTypeEnum::IfcOutletTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcOutletTypeEnum::IfcOutletTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcOutletTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcOutletTypeEnum::IfcOutletTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcOutletTypeEnum::Value Ifc4::IfcOutletTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcOutletTypeEnum::Value) Ifc4::IfcOutletTypeEnum::IfcOutletTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcOutletTypeEnum::operator Ifc4::IfcOutletTypeEnum::Value() const {
|
|
return (Ifc4::IfcOutletTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcPerformanceHistoryTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[642]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcPerformanceHistoryTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[642]); }
|
|
|
|
/*
|
|
Ifc4::IfcPerformanceHistoryTypeEnum::IfcPerformanceHistoryTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcPerformanceHistoryTypeEnum::IfcPerformanceHistoryTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcPerformanceHistoryTypeEnum::IfcPerformanceHistoryTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcPerformanceHistoryTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcPerformanceHistoryTypeEnum::IfcPerformanceHistoryTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcPerformanceHistoryTypeEnum::Value Ifc4::IfcPerformanceHistoryTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcPerformanceHistoryTypeEnum::Value) Ifc4::IfcPerformanceHistoryTypeEnum::IfcPerformanceHistoryTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcPerformanceHistoryTypeEnum::operator Ifc4::IfcPerformanceHistoryTypeEnum::Value() const {
|
|
return (Ifc4::IfcPerformanceHistoryTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcPermeableCoveringOperationEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[643]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcPermeableCoveringOperationEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[643]); }
|
|
|
|
/*
|
|
Ifc4::IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcPermeableCoveringOperationEnum::ToString(Value v) {
|
|
return Ifc4::IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcPermeableCoveringOperationEnum::Value Ifc4::IfcPermeableCoveringOperationEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcPermeableCoveringOperationEnum::Value) Ifc4::IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcPermeableCoveringOperationEnum::operator Ifc4::IfcPermeableCoveringOperationEnum::Value() const {
|
|
return (Ifc4::IfcPermeableCoveringOperationEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcPermitTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[646]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcPermitTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[646]); }
|
|
|
|
/*
|
|
Ifc4::IfcPermitTypeEnum::IfcPermitTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcPermitTypeEnum::IfcPermitTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcPermitTypeEnum::IfcPermitTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcPermitTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcPermitTypeEnum::IfcPermitTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcPermitTypeEnum::Value Ifc4::IfcPermitTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcPermitTypeEnum::Value) Ifc4::IfcPermitTypeEnum::IfcPermitTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcPermitTypeEnum::operator Ifc4::IfcPermitTypeEnum::Value() const {
|
|
return (Ifc4::IfcPermitTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcPhysicalOrVirtualEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[651]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcPhysicalOrVirtualEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[651]); }
|
|
|
|
/*
|
|
Ifc4::IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcPhysicalOrVirtualEnum::ToString(Value v) {
|
|
return Ifc4::IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcPhysicalOrVirtualEnum::Value Ifc4::IfcPhysicalOrVirtualEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcPhysicalOrVirtualEnum::Value) Ifc4::IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcPhysicalOrVirtualEnum::operator Ifc4::IfcPhysicalOrVirtualEnum::Value() const {
|
|
return (Ifc4::IfcPhysicalOrVirtualEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcPileConstructionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[655]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcPileConstructionEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[655]); }
|
|
|
|
/*
|
|
Ifc4::IfcPileConstructionEnum::IfcPileConstructionEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcPileConstructionEnum::IfcPileConstructionEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcPileConstructionEnum::IfcPileConstructionEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcPileConstructionEnum::ToString(Value v) {
|
|
return Ifc4::IfcPileConstructionEnum::IfcPileConstructionEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcPileConstructionEnum::Value Ifc4::IfcPileConstructionEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcPileConstructionEnum::Value) Ifc4::IfcPileConstructionEnum::IfcPileConstructionEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcPileConstructionEnum::operator Ifc4::IfcPileConstructionEnum::Value() const {
|
|
return (Ifc4::IfcPileConstructionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcPileTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[657]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcPileTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[657]); }
|
|
|
|
/*
|
|
Ifc4::IfcPileTypeEnum::IfcPileTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcPileTypeEnum::IfcPileTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcPileTypeEnum::IfcPileTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcPileTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcPileTypeEnum::IfcPileTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcPileTypeEnum::Value Ifc4::IfcPileTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcPileTypeEnum::Value) Ifc4::IfcPileTypeEnum::IfcPileTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcPileTypeEnum::operator Ifc4::IfcPileTypeEnum::Value() const {
|
|
return (Ifc4::IfcPileTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcPipeFittingTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[660]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcPipeFittingTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[660]); }
|
|
|
|
/*
|
|
Ifc4::IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcPipeFittingTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcPipeFittingTypeEnum::Value Ifc4::IfcPipeFittingTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcPipeFittingTypeEnum::Value) Ifc4::IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcPipeFittingTypeEnum::operator Ifc4::IfcPipeFittingTypeEnum::Value() const {
|
|
return (Ifc4::IfcPipeFittingTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcPipeSegmentTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[663]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcPipeSegmentTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[663]); }
|
|
|
|
/*
|
|
Ifc4::IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcPipeSegmentTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcPipeSegmentTypeEnum::Value Ifc4::IfcPipeSegmentTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcPipeSegmentTypeEnum::Value) Ifc4::IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcPipeSegmentTypeEnum::operator Ifc4::IfcPipeSegmentTypeEnum::Value() const {
|
|
return (Ifc4::IfcPipeSegmentTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcPlateTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[674]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcPlateTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[674]); }
|
|
|
|
/*
|
|
Ifc4::IfcPlateTypeEnum::IfcPlateTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcPlateTypeEnum::IfcPlateTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcPlateTypeEnum::IfcPlateTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcPlateTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcPlateTypeEnum::IfcPlateTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcPlateTypeEnum::Value Ifc4::IfcPlateTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcPlateTypeEnum::Value) Ifc4::IfcPlateTypeEnum::IfcPlateTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcPlateTypeEnum::operator Ifc4::IfcPlateTypeEnum::Value() const {
|
|
return (Ifc4::IfcPlateTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcPreferredSurfaceCurveRepresentation::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[696]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcPreferredSurfaceCurveRepresentation::Class() { return *((IfcParse::enumeration_type*)IFC4_types[696]); }
|
|
|
|
/*
|
|
Ifc4::IfcPreferredSurfaceCurveRepresentation::IfcPreferredSurfaceCurveRepresentation(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcPreferredSurfaceCurveRepresentation::IfcPreferredSurfaceCurveRepresentation(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcPreferredSurfaceCurveRepresentation::IfcPreferredSurfaceCurveRepresentation(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcPreferredSurfaceCurveRepresentation::ToString(Value v) {
|
|
return Ifc4::IfcPreferredSurfaceCurveRepresentation::IfcPreferredSurfaceCurveRepresentation::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcPreferredSurfaceCurveRepresentation::Value Ifc4::IfcPreferredSurfaceCurveRepresentation::FromString(const std::string& s) {
|
|
return (Ifc4::IfcPreferredSurfaceCurveRepresentation::Value) Ifc4::IfcPreferredSurfaceCurveRepresentation::IfcPreferredSurfaceCurveRepresentation::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcPreferredSurfaceCurveRepresentation::operator Ifc4::IfcPreferredSurfaceCurveRepresentation::Value() const {
|
|
return (Ifc4::IfcPreferredSurfaceCurveRepresentation::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcProcedureTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[707]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcProcedureTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[707]); }
|
|
|
|
/*
|
|
Ifc4::IfcProcedureTypeEnum::IfcProcedureTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcProcedureTypeEnum::IfcProcedureTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcProcedureTypeEnum::IfcProcedureTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcProcedureTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcProcedureTypeEnum::IfcProcedureTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcProcedureTypeEnum::Value Ifc4::IfcProcedureTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcProcedureTypeEnum::Value) Ifc4::IfcProcedureTypeEnum::IfcProcedureTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcProcedureTypeEnum::operator Ifc4::IfcProcedureTypeEnum::Value() const {
|
|
return (Ifc4::IfcProcedureTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcProfileTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[717]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcProfileTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[717]); }
|
|
|
|
/*
|
|
Ifc4::IfcProfileTypeEnum::IfcProfileTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcProfileTypeEnum::IfcProfileTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcProfileTypeEnum::IfcProfileTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcProfileTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcProfileTypeEnum::IfcProfileTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcProfileTypeEnum::Value Ifc4::IfcProfileTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcProfileTypeEnum::Value) Ifc4::IfcProfileTypeEnum::IfcProfileTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcProfileTypeEnum::operator Ifc4::IfcProfileTypeEnum::Value() const {
|
|
return (Ifc4::IfcProfileTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcProjectOrderTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[725]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcProjectOrderTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[725]); }
|
|
|
|
/*
|
|
Ifc4::IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcProjectOrderTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcProjectOrderTypeEnum::Value Ifc4::IfcProjectOrderTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcProjectOrderTypeEnum::Value) Ifc4::IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcProjectOrderTypeEnum::operator Ifc4::IfcProjectOrderTypeEnum::Value() const {
|
|
return (Ifc4::IfcProjectOrderTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcProjectedOrTrueLengthEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[720]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcProjectedOrTrueLengthEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[720]); }
|
|
|
|
/*
|
|
Ifc4::IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcProjectedOrTrueLengthEnum::ToString(Value v) {
|
|
return Ifc4::IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcProjectedOrTrueLengthEnum::Value Ifc4::IfcProjectedOrTrueLengthEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcProjectedOrTrueLengthEnum::Value) Ifc4::IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcProjectedOrTrueLengthEnum::operator Ifc4::IfcProjectedOrTrueLengthEnum::Value() const {
|
|
return (Ifc4::IfcProjectedOrTrueLengthEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcProjectionElementTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[722]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcProjectionElementTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[722]); }
|
|
|
|
/*
|
|
Ifc4::IfcProjectionElementTypeEnum::IfcProjectionElementTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcProjectionElementTypeEnum::IfcProjectionElementTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcProjectionElementTypeEnum::IfcProjectionElementTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcProjectionElementTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcProjectionElementTypeEnum::IfcProjectionElementTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcProjectionElementTypeEnum::Value Ifc4::IfcProjectionElementTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcProjectionElementTypeEnum::Value) Ifc4::IfcProjectionElementTypeEnum::IfcProjectionElementTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcProjectionElementTypeEnum::operator Ifc4::IfcProjectionElementTypeEnum::Value() const {
|
|
return (Ifc4::IfcProjectionElementTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcPropertySetTemplateTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[740]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcPropertySetTemplateTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[740]); }
|
|
|
|
/*
|
|
Ifc4::IfcPropertySetTemplateTypeEnum::IfcPropertySetTemplateTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcPropertySetTemplateTypeEnum::IfcPropertySetTemplateTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcPropertySetTemplateTypeEnum::IfcPropertySetTemplateTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcPropertySetTemplateTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcPropertySetTemplateTypeEnum::IfcPropertySetTemplateTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcPropertySetTemplateTypeEnum::Value Ifc4::IfcPropertySetTemplateTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcPropertySetTemplateTypeEnum::Value) Ifc4::IfcPropertySetTemplateTypeEnum::IfcPropertySetTemplateTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcPropertySetTemplateTypeEnum::operator Ifc4::IfcPropertySetTemplateTypeEnum::Value() const {
|
|
return (Ifc4::IfcPropertySetTemplateTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[748]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[748]); }
|
|
|
|
/*
|
|
Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::Value Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::Value) Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::operator Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::Value() const {
|
|
return (Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcProtectiveDeviceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[750]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcProtectiveDeviceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[750]); }
|
|
|
|
/*
|
|
Ifc4::IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcProtectiveDeviceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcProtectiveDeviceTypeEnum::Value Ifc4::IfcProtectiveDeviceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcProtectiveDeviceTypeEnum::Value) Ifc4::IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcProtectiveDeviceTypeEnum::operator Ifc4::IfcProtectiveDeviceTypeEnum::Value() const {
|
|
return (Ifc4::IfcProtectiveDeviceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcPumpTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[754]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcPumpTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[754]); }
|
|
|
|
/*
|
|
Ifc4::IfcPumpTypeEnum::IfcPumpTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcPumpTypeEnum::IfcPumpTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcPumpTypeEnum::IfcPumpTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcPumpTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcPumpTypeEnum::IfcPumpTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcPumpTypeEnum::Value Ifc4::IfcPumpTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcPumpTypeEnum::Value) Ifc4::IfcPumpTypeEnum::IfcPumpTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcPumpTypeEnum::operator Ifc4::IfcPumpTypeEnum::Value() const {
|
|
return (Ifc4::IfcPumpTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcRailingTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[765]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcRailingTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[765]); }
|
|
|
|
/*
|
|
Ifc4::IfcRailingTypeEnum::IfcRailingTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcRailingTypeEnum::IfcRailingTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcRailingTypeEnum::IfcRailingTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcRailingTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcRailingTypeEnum::IfcRailingTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcRailingTypeEnum::Value Ifc4::IfcRailingTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcRailingTypeEnum::Value) Ifc4::IfcRailingTypeEnum::IfcRailingTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcRailingTypeEnum::operator Ifc4::IfcRailingTypeEnum::Value() const {
|
|
return (Ifc4::IfcRailingTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcRampFlightTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[769]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcRampFlightTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[769]); }
|
|
|
|
/*
|
|
Ifc4::IfcRampFlightTypeEnum::IfcRampFlightTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcRampFlightTypeEnum::IfcRampFlightTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcRampFlightTypeEnum::IfcRampFlightTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcRampFlightTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcRampFlightTypeEnum::IfcRampFlightTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcRampFlightTypeEnum::Value Ifc4::IfcRampFlightTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcRampFlightTypeEnum::Value) Ifc4::IfcRampFlightTypeEnum::IfcRampFlightTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcRampFlightTypeEnum::operator Ifc4::IfcRampFlightTypeEnum::Value() const {
|
|
return (Ifc4::IfcRampFlightTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcRampTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[771]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcRampTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[771]); }
|
|
|
|
/*
|
|
Ifc4::IfcRampTypeEnum::IfcRampTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcRampTypeEnum::IfcRampTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcRampTypeEnum::IfcRampTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcRampTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcRampTypeEnum::IfcRampTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcRampTypeEnum::Value Ifc4::IfcRampTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcRampTypeEnum::Value) Ifc4::IfcRampTypeEnum::IfcRampTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcRampTypeEnum::operator Ifc4::IfcRampTypeEnum::Value() const {
|
|
return (Ifc4::IfcRampTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcRecurrenceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[781]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcRecurrenceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[781]); }
|
|
|
|
/*
|
|
Ifc4::IfcRecurrenceTypeEnum::IfcRecurrenceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcRecurrenceTypeEnum::IfcRecurrenceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcRecurrenceTypeEnum::IfcRecurrenceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcRecurrenceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcRecurrenceTypeEnum::IfcRecurrenceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcRecurrenceTypeEnum::Value Ifc4::IfcRecurrenceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcRecurrenceTypeEnum::Value) Ifc4::IfcRecurrenceTypeEnum::IfcRecurrenceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcRecurrenceTypeEnum::operator Ifc4::IfcRecurrenceTypeEnum::Value() const {
|
|
return (Ifc4::IfcRecurrenceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcReflectanceMethodEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[783]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcReflectanceMethodEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[783]); }
|
|
|
|
/*
|
|
Ifc4::IfcReflectanceMethodEnum::IfcReflectanceMethodEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcReflectanceMethodEnum::IfcReflectanceMethodEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcReflectanceMethodEnum::IfcReflectanceMethodEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcReflectanceMethodEnum::ToString(Value v) {
|
|
return Ifc4::IfcReflectanceMethodEnum::IfcReflectanceMethodEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcReflectanceMethodEnum::Value Ifc4::IfcReflectanceMethodEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcReflectanceMethodEnum::Value) Ifc4::IfcReflectanceMethodEnum::IfcReflectanceMethodEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcReflectanceMethodEnum::operator Ifc4::IfcReflectanceMethodEnum::Value() const {
|
|
return (Ifc4::IfcReflectanceMethodEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcReinforcingBarRoleEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[788]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcReinforcingBarRoleEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[788]); }
|
|
|
|
/*
|
|
Ifc4::IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcReinforcingBarRoleEnum::ToString(Value v) {
|
|
return Ifc4::IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcReinforcingBarRoleEnum::Value Ifc4::IfcReinforcingBarRoleEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcReinforcingBarRoleEnum::Value) Ifc4::IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcReinforcingBarRoleEnum::operator Ifc4::IfcReinforcingBarRoleEnum::Value() const {
|
|
return (Ifc4::IfcReinforcingBarRoleEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcReinforcingBarSurfaceEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[789]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcReinforcingBarSurfaceEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[789]); }
|
|
|
|
/*
|
|
Ifc4::IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcReinforcingBarSurfaceEnum::ToString(Value v) {
|
|
return Ifc4::IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcReinforcingBarSurfaceEnum::Value Ifc4::IfcReinforcingBarSurfaceEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcReinforcingBarSurfaceEnum::Value) Ifc4::IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcReinforcingBarSurfaceEnum::operator Ifc4::IfcReinforcingBarSurfaceEnum::Value() const {
|
|
return (Ifc4::IfcReinforcingBarSurfaceEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcReinforcingBarTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[791]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcReinforcingBarTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[791]); }
|
|
|
|
/*
|
|
Ifc4::IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcReinforcingBarTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcReinforcingBarTypeEnum::Value Ifc4::IfcReinforcingBarTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcReinforcingBarTypeEnum::Value) Ifc4::IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcReinforcingBarTypeEnum::operator Ifc4::IfcReinforcingBarTypeEnum::Value() const {
|
|
return (Ifc4::IfcReinforcingBarTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcReinforcingMeshTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[796]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcReinforcingMeshTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[796]); }
|
|
|
|
/*
|
|
Ifc4::IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcReinforcingMeshTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcReinforcingMeshTypeEnum::Value Ifc4::IfcReinforcingMeshTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcReinforcingMeshTypeEnum::Value) Ifc4::IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcReinforcingMeshTypeEnum::operator Ifc4::IfcReinforcingMeshTypeEnum::Value() const {
|
|
return (Ifc4::IfcReinforcingMeshTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcRoleEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[861]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcRoleEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[861]); }
|
|
|
|
/*
|
|
Ifc4::IfcRoleEnum::IfcRoleEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcRoleEnum::IfcRoleEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcRoleEnum::IfcRoleEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcRoleEnum::ToString(Value v) {
|
|
return Ifc4::IfcRoleEnum::IfcRoleEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcRoleEnum::Value Ifc4::IfcRoleEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcRoleEnum::Value) Ifc4::IfcRoleEnum::IfcRoleEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcRoleEnum::operator Ifc4::IfcRoleEnum::Value() const {
|
|
return (Ifc4::IfcRoleEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcRoofTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[864]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcRoofTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[864]); }
|
|
|
|
/*
|
|
Ifc4::IfcRoofTypeEnum::IfcRoofTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcRoofTypeEnum::IfcRoofTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcRoofTypeEnum::IfcRoofTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcRoofTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcRoofTypeEnum::IfcRoofTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcRoofTypeEnum::Value Ifc4::IfcRoofTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcRoofTypeEnum::Value) Ifc4::IfcRoofTypeEnum::IfcRoofTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcRoofTypeEnum::operator Ifc4::IfcRoofTypeEnum::Value() const {
|
|
return (Ifc4::IfcRoofTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcSIPrefix::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[900]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcSIPrefix::Class() { return *((IfcParse::enumeration_type*)IFC4_types[900]); }
|
|
|
|
/*
|
|
Ifc4::IfcSIPrefix::IfcSIPrefix(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcSIPrefix::IfcSIPrefix(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcSIPrefix::IfcSIPrefix(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcSIPrefix::ToString(Value v) {
|
|
return Ifc4::IfcSIPrefix::IfcSIPrefix::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcSIPrefix::Value Ifc4::IfcSIPrefix::FromString(const std::string& s) {
|
|
return (Ifc4::IfcSIPrefix::Value) Ifc4::IfcSIPrefix::IfcSIPrefix::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcSIPrefix::operator Ifc4::IfcSIPrefix::Value() const {
|
|
return (Ifc4::IfcSIPrefix::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcSIUnitName::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[903]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcSIUnitName::Class() { return *((IfcParse::enumeration_type*)IFC4_types[903]); }
|
|
|
|
/*
|
|
Ifc4::IfcSIUnitName::IfcSIUnitName(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcSIUnitName::IfcSIUnitName(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcSIUnitName::IfcSIUnitName(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcSIUnitName::ToString(Value v) {
|
|
return Ifc4::IfcSIUnitName::IfcSIUnitName::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcSIUnitName::Value Ifc4::IfcSIUnitName::FromString(const std::string& s) {
|
|
return (Ifc4::IfcSIUnitName::Value) Ifc4::IfcSIUnitName::IfcSIUnitName::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcSIUnitName::operator Ifc4::IfcSIUnitName::Value() const {
|
|
return (Ifc4::IfcSIUnitName::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcSanitaryTerminalTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[873]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcSanitaryTerminalTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[873]); }
|
|
|
|
/*
|
|
Ifc4::IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcSanitaryTerminalTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcSanitaryTerminalTypeEnum::Value Ifc4::IfcSanitaryTerminalTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcSanitaryTerminalTypeEnum::Value) Ifc4::IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcSanitaryTerminalTypeEnum::operator Ifc4::IfcSanitaryTerminalTypeEnum::Value() const {
|
|
return (Ifc4::IfcSanitaryTerminalTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcSectionTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[881]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcSectionTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[881]); }
|
|
|
|
/*
|
|
Ifc4::IfcSectionTypeEnum::IfcSectionTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcSectionTypeEnum::IfcSectionTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcSectionTypeEnum::IfcSectionTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcSectionTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcSectionTypeEnum::IfcSectionTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcSectionTypeEnum::Value Ifc4::IfcSectionTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcSectionTypeEnum::Value) Ifc4::IfcSectionTypeEnum::IfcSectionTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcSectionTypeEnum::operator Ifc4::IfcSectionTypeEnum::Value() const {
|
|
return (Ifc4::IfcSectionTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcSensorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[885]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcSensorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[885]); }
|
|
|
|
/*
|
|
Ifc4::IfcSensorTypeEnum::IfcSensorTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcSensorTypeEnum::IfcSensorTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcSensorTypeEnum::IfcSensorTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcSensorTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcSensorTypeEnum::IfcSensorTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcSensorTypeEnum::Value Ifc4::IfcSensorTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcSensorTypeEnum::Value) Ifc4::IfcSensorTypeEnum::IfcSensorTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcSensorTypeEnum::operator Ifc4::IfcSensorTypeEnum::Value() const {
|
|
return (Ifc4::IfcSensorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcSequenceEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[886]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcSequenceEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[886]); }
|
|
|
|
/*
|
|
Ifc4::IfcSequenceEnum::IfcSequenceEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcSequenceEnum::IfcSequenceEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcSequenceEnum::IfcSequenceEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcSequenceEnum::ToString(Value v) {
|
|
return Ifc4::IfcSequenceEnum::IfcSequenceEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcSequenceEnum::Value Ifc4::IfcSequenceEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcSequenceEnum::Value) Ifc4::IfcSequenceEnum::IfcSequenceEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcSequenceEnum::operator Ifc4::IfcSequenceEnum::Value() const {
|
|
return (Ifc4::IfcSequenceEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcShadingDeviceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[889]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcShadingDeviceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[889]); }
|
|
|
|
/*
|
|
Ifc4::IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcShadingDeviceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcShadingDeviceTypeEnum::Value Ifc4::IfcShadingDeviceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcShadingDeviceTypeEnum::Value) Ifc4::IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcShadingDeviceTypeEnum::operator Ifc4::IfcShadingDeviceTypeEnum::Value() const {
|
|
return (Ifc4::IfcShadingDeviceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcSimplePropertyTemplateTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[898]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcSimplePropertyTemplateTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[898]); }
|
|
|
|
/*
|
|
Ifc4::IfcSimplePropertyTemplateTypeEnum::IfcSimplePropertyTemplateTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcSimplePropertyTemplateTypeEnum::IfcSimplePropertyTemplateTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcSimplePropertyTemplateTypeEnum::IfcSimplePropertyTemplateTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcSimplePropertyTemplateTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcSimplePropertyTemplateTypeEnum::IfcSimplePropertyTemplateTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcSimplePropertyTemplateTypeEnum::Value Ifc4::IfcSimplePropertyTemplateTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcSimplePropertyTemplateTypeEnum::Value) Ifc4::IfcSimplePropertyTemplateTypeEnum::IfcSimplePropertyTemplateTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcSimplePropertyTemplateTypeEnum::operator Ifc4::IfcSimplePropertyTemplateTypeEnum::Value() const {
|
|
return (Ifc4::IfcSimplePropertyTemplateTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcSlabTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[909]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcSlabTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[909]); }
|
|
|
|
/*
|
|
Ifc4::IfcSlabTypeEnum::IfcSlabTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcSlabTypeEnum::IfcSlabTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcSlabTypeEnum::IfcSlabTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcSlabTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcSlabTypeEnum::IfcSlabTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcSlabTypeEnum::Value Ifc4::IfcSlabTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcSlabTypeEnum::Value) Ifc4::IfcSlabTypeEnum::IfcSlabTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcSlabTypeEnum::operator Ifc4::IfcSlabTypeEnum::Value() const {
|
|
return (Ifc4::IfcSlabTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcSolarDeviceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[913]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcSolarDeviceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[913]); }
|
|
|
|
/*
|
|
Ifc4::IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcSolarDeviceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcSolarDeviceTypeEnum::Value Ifc4::IfcSolarDeviceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcSolarDeviceTypeEnum::Value) Ifc4::IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcSolarDeviceTypeEnum::operator Ifc4::IfcSolarDeviceTypeEnum::Value() const {
|
|
return (Ifc4::IfcSolarDeviceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcSpaceHeaterTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[925]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcSpaceHeaterTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[925]); }
|
|
|
|
/*
|
|
Ifc4::IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcSpaceHeaterTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcSpaceHeaterTypeEnum::Value Ifc4::IfcSpaceHeaterTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcSpaceHeaterTypeEnum::Value) Ifc4::IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcSpaceHeaterTypeEnum::operator Ifc4::IfcSpaceHeaterTypeEnum::Value() const {
|
|
return (Ifc4::IfcSpaceHeaterTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcSpaceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[927]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcSpaceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[927]); }
|
|
|
|
/*
|
|
Ifc4::IfcSpaceTypeEnum::IfcSpaceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcSpaceTypeEnum::IfcSpaceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcSpaceTypeEnum::IfcSpaceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcSpaceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcSpaceTypeEnum::IfcSpaceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcSpaceTypeEnum::Value Ifc4::IfcSpaceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcSpaceTypeEnum::Value) Ifc4::IfcSpaceTypeEnum::IfcSpaceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcSpaceTypeEnum::operator Ifc4::IfcSpaceTypeEnum::Value() const {
|
|
return (Ifc4::IfcSpaceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcSpatialZoneTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[934]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcSpatialZoneTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[934]); }
|
|
|
|
/*
|
|
Ifc4::IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcSpatialZoneTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcSpatialZoneTypeEnum::Value Ifc4::IfcSpatialZoneTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcSpatialZoneTypeEnum::Value) Ifc4::IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcSpatialZoneTypeEnum::operator Ifc4::IfcSpatialZoneTypeEnum::Value() const {
|
|
return (Ifc4::IfcSpatialZoneTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcStackTerminalTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[943]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcStackTerminalTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[943]); }
|
|
|
|
/*
|
|
Ifc4::IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcStackTerminalTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcStackTerminalTypeEnum::Value Ifc4::IfcStackTerminalTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcStackTerminalTypeEnum::Value) Ifc4::IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcStackTerminalTypeEnum::operator Ifc4::IfcStackTerminalTypeEnum::Value() const {
|
|
return (Ifc4::IfcStackTerminalTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcStairFlightTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[947]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcStairFlightTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[947]); }
|
|
|
|
/*
|
|
Ifc4::IfcStairFlightTypeEnum::IfcStairFlightTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcStairFlightTypeEnum::IfcStairFlightTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcStairFlightTypeEnum::IfcStairFlightTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcStairFlightTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcStairFlightTypeEnum::IfcStairFlightTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcStairFlightTypeEnum::Value Ifc4::IfcStairFlightTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcStairFlightTypeEnum::Value) Ifc4::IfcStairFlightTypeEnum::IfcStairFlightTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcStairFlightTypeEnum::operator Ifc4::IfcStairFlightTypeEnum::Value() const {
|
|
return (Ifc4::IfcStairFlightTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcStairTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[949]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcStairTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[949]); }
|
|
|
|
/*
|
|
Ifc4::IfcStairTypeEnum::IfcStairTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcStairTypeEnum::IfcStairTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcStairTypeEnum::IfcStairTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcStairTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcStairTypeEnum::IfcStairTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcStairTypeEnum::Value Ifc4::IfcStairTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcStairTypeEnum::Value) Ifc4::IfcStairTypeEnum::IfcStairTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcStairTypeEnum::operator Ifc4::IfcStairTypeEnum::Value() const {
|
|
return (Ifc4::IfcStairTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcStateEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[950]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcStateEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[950]); }
|
|
|
|
/*
|
|
Ifc4::IfcStateEnum::IfcStateEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcStateEnum::IfcStateEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcStateEnum::IfcStateEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcStateEnum::ToString(Value v) {
|
|
return Ifc4::IfcStateEnum::IfcStateEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcStateEnum::Value Ifc4::IfcStateEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcStateEnum::Value) Ifc4::IfcStateEnum::IfcStateEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcStateEnum::operator Ifc4::IfcStateEnum::Value() const {
|
|
return (Ifc4::IfcStateEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcStructuralCurveActivityTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[958]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcStructuralCurveActivityTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[958]); }
|
|
|
|
/*
|
|
Ifc4::IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcStructuralCurveActivityTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcStructuralCurveActivityTypeEnum::Value Ifc4::IfcStructuralCurveActivityTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcStructuralCurveActivityTypeEnum::Value) Ifc4::IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcStructuralCurveActivityTypeEnum::operator Ifc4::IfcStructuralCurveActivityTypeEnum::Value() const {
|
|
return (Ifc4::IfcStructuralCurveActivityTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcStructuralCurveMemberTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[961]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcStructuralCurveMemberTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[961]); }
|
|
|
|
/*
|
|
Ifc4::IfcStructuralCurveMemberTypeEnum::IfcStructuralCurveMemberTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcStructuralCurveMemberTypeEnum::IfcStructuralCurveMemberTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcStructuralCurveMemberTypeEnum::IfcStructuralCurveMemberTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcStructuralCurveMemberTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcStructuralCurveMemberTypeEnum::IfcStructuralCurveMemberTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcStructuralCurveMemberTypeEnum::Value Ifc4::IfcStructuralCurveMemberTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcStructuralCurveMemberTypeEnum::Value) Ifc4::IfcStructuralCurveMemberTypeEnum::IfcStructuralCurveMemberTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcStructuralCurveMemberTypeEnum::operator Ifc4::IfcStructuralCurveMemberTypeEnum::Value() const {
|
|
return (Ifc4::IfcStructuralCurveMemberTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcStructuralSurfaceActivityTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[987]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcStructuralSurfaceActivityTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[987]); }
|
|
|
|
/*
|
|
Ifc4::IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcStructuralSurfaceActivityTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcStructuralSurfaceActivityTypeEnum::Value Ifc4::IfcStructuralSurfaceActivityTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcStructuralSurfaceActivityTypeEnum::Value) Ifc4::IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcStructuralSurfaceActivityTypeEnum::operator Ifc4::IfcStructuralSurfaceActivityTypeEnum::Value() const {
|
|
return (Ifc4::IfcStructuralSurfaceActivityTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcStructuralSurfaceMemberTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[990]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcStructuralSurfaceMemberTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[990]); }
|
|
|
|
/*
|
|
Ifc4::IfcStructuralSurfaceMemberTypeEnum::IfcStructuralSurfaceMemberTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcStructuralSurfaceMemberTypeEnum::IfcStructuralSurfaceMemberTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcStructuralSurfaceMemberTypeEnum::IfcStructuralSurfaceMemberTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcStructuralSurfaceMemberTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcStructuralSurfaceMemberTypeEnum::IfcStructuralSurfaceMemberTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcStructuralSurfaceMemberTypeEnum::Value Ifc4::IfcStructuralSurfaceMemberTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcStructuralSurfaceMemberTypeEnum::Value) Ifc4::IfcStructuralSurfaceMemberTypeEnum::IfcStructuralSurfaceMemberTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcStructuralSurfaceMemberTypeEnum::operator Ifc4::IfcStructuralSurfaceMemberTypeEnum::Value() const {
|
|
return (Ifc4::IfcStructuralSurfaceMemberTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcSubContractResourceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[999]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcSubContractResourceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[999]); }
|
|
|
|
/*
|
|
Ifc4::IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcSubContractResourceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcSubContractResourceTypeEnum::Value Ifc4::IfcSubContractResourceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcSubContractResourceTypeEnum::Value) Ifc4::IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcSubContractResourceTypeEnum::operator Ifc4::IfcSubContractResourceTypeEnum::Value() const {
|
|
return (Ifc4::IfcSubContractResourceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcSurfaceFeatureTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1005]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcSurfaceFeatureTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1005]); }
|
|
|
|
/*
|
|
Ifc4::IfcSurfaceFeatureTypeEnum::IfcSurfaceFeatureTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcSurfaceFeatureTypeEnum::IfcSurfaceFeatureTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcSurfaceFeatureTypeEnum::IfcSurfaceFeatureTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcSurfaceFeatureTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcSurfaceFeatureTypeEnum::IfcSurfaceFeatureTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcSurfaceFeatureTypeEnum::Value Ifc4::IfcSurfaceFeatureTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcSurfaceFeatureTypeEnum::Value) Ifc4::IfcSurfaceFeatureTypeEnum::IfcSurfaceFeatureTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcSurfaceFeatureTypeEnum::operator Ifc4::IfcSurfaceFeatureTypeEnum::Value() const {
|
|
return (Ifc4::IfcSurfaceFeatureTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcSurfaceSide::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1010]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcSurfaceSide::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1010]); }
|
|
|
|
/*
|
|
Ifc4::IfcSurfaceSide::IfcSurfaceSide(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcSurfaceSide::IfcSurfaceSide(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcSurfaceSide::IfcSurfaceSide(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcSurfaceSide::ToString(Value v) {
|
|
return Ifc4::IfcSurfaceSide::IfcSurfaceSide::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcSurfaceSide::Value Ifc4::IfcSurfaceSide::FromString(const std::string& s) {
|
|
return (Ifc4::IfcSurfaceSide::Value) Ifc4::IfcSurfaceSide::IfcSurfaceSide::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcSurfaceSide::operator Ifc4::IfcSurfaceSide::Value() const {
|
|
return (Ifc4::IfcSurfaceSide::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcSwitchingDeviceTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1025]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcSwitchingDeviceTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1025]); }
|
|
|
|
/*
|
|
Ifc4::IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcSwitchingDeviceTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcSwitchingDeviceTypeEnum::Value Ifc4::IfcSwitchingDeviceTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcSwitchingDeviceTypeEnum::Value) Ifc4::IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcSwitchingDeviceTypeEnum::operator Ifc4::IfcSwitchingDeviceTypeEnum::Value() const {
|
|
return (Ifc4::IfcSwitchingDeviceTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcSystemFurnitureElementTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1029]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcSystemFurnitureElementTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1029]); }
|
|
|
|
/*
|
|
Ifc4::IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcSystemFurnitureElementTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcSystemFurnitureElementTypeEnum::Value Ifc4::IfcSystemFurnitureElementTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcSystemFurnitureElementTypeEnum::Value) Ifc4::IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcSystemFurnitureElementTypeEnum::operator Ifc4::IfcSystemFurnitureElementTypeEnum::Value() const {
|
|
return (Ifc4::IfcSystemFurnitureElementTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcTankTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1035]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcTankTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1035]); }
|
|
|
|
/*
|
|
Ifc4::IfcTankTypeEnum::IfcTankTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcTankTypeEnum::IfcTankTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcTankTypeEnum::IfcTankTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcTankTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcTankTypeEnum::IfcTankTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcTankTypeEnum::Value Ifc4::IfcTankTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcTankTypeEnum::Value) Ifc4::IfcTankTypeEnum::IfcTankTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcTankTypeEnum::operator Ifc4::IfcTankTypeEnum::Value() const {
|
|
return (Ifc4::IfcTankTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcTaskDurationEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1037]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcTaskDurationEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1037]); }
|
|
|
|
/*
|
|
Ifc4::IfcTaskDurationEnum::IfcTaskDurationEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcTaskDurationEnum::IfcTaskDurationEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcTaskDurationEnum::IfcTaskDurationEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcTaskDurationEnum::ToString(Value v) {
|
|
return Ifc4::IfcTaskDurationEnum::IfcTaskDurationEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcTaskDurationEnum::Value Ifc4::IfcTaskDurationEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcTaskDurationEnum::Value) Ifc4::IfcTaskDurationEnum::IfcTaskDurationEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcTaskDurationEnum::operator Ifc4::IfcTaskDurationEnum::Value() const {
|
|
return (Ifc4::IfcTaskDurationEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcTaskTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1041]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcTaskTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1041]); }
|
|
|
|
/*
|
|
Ifc4::IfcTaskTypeEnum::IfcTaskTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcTaskTypeEnum::IfcTaskTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcTaskTypeEnum::IfcTaskTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcTaskTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcTaskTypeEnum::IfcTaskTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcTaskTypeEnum::Value Ifc4::IfcTaskTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcTaskTypeEnum::Value) Ifc4::IfcTaskTypeEnum::IfcTaskTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcTaskTypeEnum::operator Ifc4::IfcTaskTypeEnum::Value() const {
|
|
return (Ifc4::IfcTaskTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcTendonAnchorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1048]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcTendonAnchorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1048]); }
|
|
|
|
/*
|
|
Ifc4::IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcTendonAnchorTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcTendonAnchorTypeEnum::Value Ifc4::IfcTendonAnchorTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcTendonAnchorTypeEnum::Value) Ifc4::IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcTendonAnchorTypeEnum::operator Ifc4::IfcTendonAnchorTypeEnum::Value() const {
|
|
return (Ifc4::IfcTendonAnchorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcTendonTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1050]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcTendonTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1050]); }
|
|
|
|
/*
|
|
Ifc4::IfcTendonTypeEnum::IfcTendonTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcTendonTypeEnum::IfcTendonTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcTendonTypeEnum::IfcTendonTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcTendonTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcTendonTypeEnum::IfcTendonTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcTendonTypeEnum::Value Ifc4::IfcTendonTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcTendonTypeEnum::Value) Ifc4::IfcTendonTypeEnum::IfcTendonTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcTendonTypeEnum::operator Ifc4::IfcTendonTypeEnum::Value() const {
|
|
return (Ifc4::IfcTendonTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcTextPath::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1060]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcTextPath::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1060]); }
|
|
|
|
/*
|
|
Ifc4::IfcTextPath::IfcTextPath(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcTextPath::IfcTextPath(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcTextPath::IfcTextPath(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcTextPath::ToString(Value v) {
|
|
return Ifc4::IfcTextPath::IfcTextPath::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcTextPath::Value Ifc4::IfcTextPath::FromString(const std::string& s) {
|
|
return (Ifc4::IfcTextPath::Value) Ifc4::IfcTextPath::IfcTextPath::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcTextPath::operator Ifc4::IfcTextPath::Value() const {
|
|
return (Ifc4::IfcTextPath::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcTimeSeriesDataTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1082]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcTimeSeriesDataTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1082]); }
|
|
|
|
/*
|
|
Ifc4::IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcTimeSeriesDataTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcTimeSeriesDataTypeEnum::Value Ifc4::IfcTimeSeriesDataTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcTimeSeriesDataTypeEnum::Value) Ifc4::IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcTimeSeriesDataTypeEnum::operator Ifc4::IfcTimeSeriesDataTypeEnum::Value() const {
|
|
return (Ifc4::IfcTimeSeriesDataTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcTransformerTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1091]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcTransformerTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1091]); }
|
|
|
|
/*
|
|
Ifc4::IfcTransformerTypeEnum::IfcTransformerTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcTransformerTypeEnum::IfcTransformerTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcTransformerTypeEnum::IfcTransformerTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcTransformerTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcTransformerTypeEnum::IfcTransformerTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcTransformerTypeEnum::Value Ifc4::IfcTransformerTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcTransformerTypeEnum::Value) Ifc4::IfcTransformerTypeEnum::IfcTransformerTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcTransformerTypeEnum::operator Ifc4::IfcTransformerTypeEnum::Value() const {
|
|
return (Ifc4::IfcTransformerTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcTransitionCode::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1092]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcTransitionCode::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1092]); }
|
|
|
|
/*
|
|
Ifc4::IfcTransitionCode::IfcTransitionCode(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcTransitionCode::IfcTransitionCode(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcTransitionCode::IfcTransitionCode(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcTransitionCode::ToString(Value v) {
|
|
return Ifc4::IfcTransitionCode::IfcTransitionCode::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcTransitionCode::Value Ifc4::IfcTransitionCode::FromString(const std::string& s) {
|
|
return (Ifc4::IfcTransitionCode::Value) Ifc4::IfcTransitionCode::IfcTransitionCode::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcTransitionCode::operator Ifc4::IfcTransitionCode::Value() const {
|
|
return (Ifc4::IfcTransitionCode::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcTransportElementTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1096]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcTransportElementTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1096]); }
|
|
|
|
/*
|
|
Ifc4::IfcTransportElementTypeEnum::IfcTransportElementTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcTransportElementTypeEnum::IfcTransportElementTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcTransportElementTypeEnum::IfcTransportElementTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcTransportElementTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcTransportElementTypeEnum::IfcTransportElementTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcTransportElementTypeEnum::Value Ifc4::IfcTransportElementTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcTransportElementTypeEnum::Value) Ifc4::IfcTransportElementTypeEnum::IfcTransportElementTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcTransportElementTypeEnum::operator Ifc4::IfcTransportElementTypeEnum::Value() const {
|
|
return (Ifc4::IfcTransportElementTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcTrimmingPreference::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1100]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcTrimmingPreference::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1100]); }
|
|
|
|
/*
|
|
Ifc4::IfcTrimmingPreference::IfcTrimmingPreference(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcTrimmingPreference::IfcTrimmingPreference(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcTrimmingPreference::IfcTrimmingPreference(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcTrimmingPreference::ToString(Value v) {
|
|
return Ifc4::IfcTrimmingPreference::IfcTrimmingPreference::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcTrimmingPreference::Value Ifc4::IfcTrimmingPreference::FromString(const std::string& s) {
|
|
return (Ifc4::IfcTrimmingPreference::Value) Ifc4::IfcTrimmingPreference::IfcTrimmingPreference::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcTrimmingPreference::operator Ifc4::IfcTrimmingPreference::Value() const {
|
|
return (Ifc4::IfcTrimmingPreference::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcTubeBundleTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1105]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcTubeBundleTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1105]); }
|
|
|
|
/*
|
|
Ifc4::IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcTubeBundleTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcTubeBundleTypeEnum::Value Ifc4::IfcTubeBundleTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcTubeBundleTypeEnum::Value) Ifc4::IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcTubeBundleTypeEnum::operator Ifc4::IfcTubeBundleTypeEnum::Value() const {
|
|
return (Ifc4::IfcTubeBundleTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcUnitEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1118]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcUnitEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1118]); }
|
|
|
|
/*
|
|
Ifc4::IfcUnitEnum::IfcUnitEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcUnitEnum::IfcUnitEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcUnitEnum::IfcUnitEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcUnitEnum::ToString(Value v) {
|
|
return Ifc4::IfcUnitEnum::IfcUnitEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcUnitEnum::Value Ifc4::IfcUnitEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcUnitEnum::Value) Ifc4::IfcUnitEnum::IfcUnitEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcUnitEnum::operator Ifc4::IfcUnitEnum::Value() const {
|
|
return (Ifc4::IfcUnitEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcUnitaryControlElementTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1113]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcUnitaryControlElementTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1113]); }
|
|
|
|
/*
|
|
Ifc4::IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcUnitaryControlElementTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcUnitaryControlElementTypeEnum::Value Ifc4::IfcUnitaryControlElementTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcUnitaryControlElementTypeEnum::Value) Ifc4::IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcUnitaryControlElementTypeEnum::operator Ifc4::IfcUnitaryControlElementTypeEnum::Value() const {
|
|
return (Ifc4::IfcUnitaryControlElementTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcUnitaryEquipmentTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1116]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcUnitaryEquipmentTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1116]); }
|
|
|
|
/*
|
|
Ifc4::IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcUnitaryEquipmentTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcUnitaryEquipmentTypeEnum::Value Ifc4::IfcUnitaryEquipmentTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcUnitaryEquipmentTypeEnum::Value) Ifc4::IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcUnitaryEquipmentTypeEnum::operator Ifc4::IfcUnitaryEquipmentTypeEnum::Value() const {
|
|
return (Ifc4::IfcUnitaryEquipmentTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcValveTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1124]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcValveTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1124]); }
|
|
|
|
/*
|
|
Ifc4::IfcValveTypeEnum::IfcValveTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcValveTypeEnum::IfcValveTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcValveTypeEnum::IfcValveTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcValveTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcValveTypeEnum::IfcValveTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcValveTypeEnum::Value Ifc4::IfcValveTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcValveTypeEnum::Value) Ifc4::IfcValveTypeEnum::IfcValveTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcValveTypeEnum::operator Ifc4::IfcValveTypeEnum::Value() const {
|
|
return (Ifc4::IfcValveTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcVibrationIsolatorTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1133]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcVibrationIsolatorTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1133]); }
|
|
|
|
/*
|
|
Ifc4::IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcVibrationIsolatorTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcVibrationIsolatorTypeEnum::Value Ifc4::IfcVibrationIsolatorTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcVibrationIsolatorTypeEnum::Value) Ifc4::IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcVibrationIsolatorTypeEnum::operator Ifc4::IfcVibrationIsolatorTypeEnum::Value() const {
|
|
return (Ifc4::IfcVibrationIsolatorTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcVoidingFeatureTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1137]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcVoidingFeatureTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1137]); }
|
|
|
|
/*
|
|
Ifc4::IfcVoidingFeatureTypeEnum::IfcVoidingFeatureTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcVoidingFeatureTypeEnum::IfcVoidingFeatureTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcVoidingFeatureTypeEnum::IfcVoidingFeatureTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcVoidingFeatureTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcVoidingFeatureTypeEnum::IfcVoidingFeatureTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcVoidingFeatureTypeEnum::Value Ifc4::IfcVoidingFeatureTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcVoidingFeatureTypeEnum::Value) Ifc4::IfcVoidingFeatureTypeEnum::IfcVoidingFeatureTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcVoidingFeatureTypeEnum::operator Ifc4::IfcVoidingFeatureTypeEnum::Value() const {
|
|
return (Ifc4::IfcVoidingFeatureTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcWallTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1144]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcWallTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1144]); }
|
|
|
|
/*
|
|
Ifc4::IfcWallTypeEnum::IfcWallTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcWallTypeEnum::IfcWallTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcWallTypeEnum::IfcWallTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcWallTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcWallTypeEnum::IfcWallTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcWallTypeEnum::Value Ifc4::IfcWallTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcWallTypeEnum::Value) Ifc4::IfcWallTypeEnum::IfcWallTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcWallTypeEnum::operator Ifc4::IfcWallTypeEnum::Value() const {
|
|
return (Ifc4::IfcWallTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcWasteTerminalTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1150]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcWasteTerminalTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1150]); }
|
|
|
|
/*
|
|
Ifc4::IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcWasteTerminalTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcWasteTerminalTypeEnum::Value Ifc4::IfcWasteTerminalTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcWasteTerminalTypeEnum::Value) Ifc4::IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcWasteTerminalTypeEnum::operator Ifc4::IfcWasteTerminalTypeEnum::Value() const {
|
|
return (Ifc4::IfcWasteTerminalTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcWindowPanelOperationEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1153]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcWindowPanelOperationEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1153]); }
|
|
|
|
/*
|
|
Ifc4::IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcWindowPanelOperationEnum::ToString(Value v) {
|
|
return Ifc4::IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcWindowPanelOperationEnum::Value Ifc4::IfcWindowPanelOperationEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcWindowPanelOperationEnum::Value) Ifc4::IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcWindowPanelOperationEnum::operator Ifc4::IfcWindowPanelOperationEnum::Value() const {
|
|
return (Ifc4::IfcWindowPanelOperationEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcWindowPanelPositionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1154]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcWindowPanelPositionEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1154]); }
|
|
|
|
/*
|
|
Ifc4::IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcWindowPanelPositionEnum::ToString(Value v) {
|
|
return Ifc4::IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcWindowPanelPositionEnum::Value Ifc4::IfcWindowPanelPositionEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcWindowPanelPositionEnum::Value) Ifc4::IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcWindowPanelPositionEnum::operator Ifc4::IfcWindowPanelPositionEnum::Value() const {
|
|
return (Ifc4::IfcWindowPanelPositionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcWindowStyleConstructionEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1158]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcWindowStyleConstructionEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1158]); }
|
|
|
|
/*
|
|
Ifc4::IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcWindowStyleConstructionEnum::ToString(Value v) {
|
|
return Ifc4::IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcWindowStyleConstructionEnum::Value Ifc4::IfcWindowStyleConstructionEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcWindowStyleConstructionEnum::Value) Ifc4::IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcWindowStyleConstructionEnum::operator Ifc4::IfcWindowStyleConstructionEnum::Value() const {
|
|
return (Ifc4::IfcWindowStyleConstructionEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcWindowStyleOperationEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1159]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcWindowStyleOperationEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1159]); }
|
|
|
|
/*
|
|
Ifc4::IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcWindowStyleOperationEnum::ToString(Value v) {
|
|
return Ifc4::IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcWindowStyleOperationEnum::Value Ifc4::IfcWindowStyleOperationEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcWindowStyleOperationEnum::Value) Ifc4::IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcWindowStyleOperationEnum::operator Ifc4::IfcWindowStyleOperationEnum::Value() const {
|
|
return (Ifc4::IfcWindowStyleOperationEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcWindowTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1161]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcWindowTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1161]); }
|
|
|
|
/*
|
|
Ifc4::IfcWindowTypeEnum::IfcWindowTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcWindowTypeEnum::IfcWindowTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcWindowTypeEnum::IfcWindowTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcWindowTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcWindowTypeEnum::IfcWindowTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcWindowTypeEnum::Value Ifc4::IfcWindowTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcWindowTypeEnum::Value) Ifc4::IfcWindowTypeEnum::IfcWindowTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcWindowTypeEnum::operator Ifc4::IfcWindowTypeEnum::Value() const {
|
|
return (Ifc4::IfcWindowTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcWindowTypePartitioningEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1162]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcWindowTypePartitioningEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1162]); }
|
|
|
|
/*
|
|
Ifc4::IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcWindowTypePartitioningEnum::ToString(Value v) {
|
|
return Ifc4::IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcWindowTypePartitioningEnum::Value Ifc4::IfcWindowTypePartitioningEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcWindowTypePartitioningEnum::Value) Ifc4::IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcWindowTypePartitioningEnum::operator Ifc4::IfcWindowTypePartitioningEnum::Value() const {
|
|
return (Ifc4::IfcWindowTypePartitioningEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcWorkCalendarTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1164]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcWorkCalendarTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1164]); }
|
|
|
|
/*
|
|
Ifc4::IfcWorkCalendarTypeEnum::IfcWorkCalendarTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcWorkCalendarTypeEnum::IfcWorkCalendarTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcWorkCalendarTypeEnum::IfcWorkCalendarTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcWorkCalendarTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcWorkCalendarTypeEnum::IfcWorkCalendarTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcWorkCalendarTypeEnum::Value Ifc4::IfcWorkCalendarTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcWorkCalendarTypeEnum::Value) Ifc4::IfcWorkCalendarTypeEnum::IfcWorkCalendarTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcWorkCalendarTypeEnum::operator Ifc4::IfcWorkCalendarTypeEnum::Value() const {
|
|
return (Ifc4::IfcWorkCalendarTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcWorkPlanTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1167]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcWorkPlanTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1167]); }
|
|
|
|
/*
|
|
Ifc4::IfcWorkPlanTypeEnum::IfcWorkPlanTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcWorkPlanTypeEnum::IfcWorkPlanTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcWorkPlanTypeEnum::IfcWorkPlanTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcWorkPlanTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcWorkPlanTypeEnum::IfcWorkPlanTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcWorkPlanTypeEnum::Value Ifc4::IfcWorkPlanTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcWorkPlanTypeEnum::Value) Ifc4::IfcWorkPlanTypeEnum::IfcWorkPlanTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcWorkPlanTypeEnum::operator Ifc4::IfcWorkPlanTypeEnum::Value() const {
|
|
return (Ifc4::IfcWorkPlanTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
// const IfcParse::enumeration_type& Ifc4::IfcWorkScheduleTypeEnum::declaration() const { return *((IfcParse::enumeration_type*)IFC4_types[1169]); }
|
|
const IfcParse::enumeration_type& Ifc4::IfcWorkScheduleTypeEnum::Class() { return *((IfcParse::enumeration_type*)IFC4_types[1169]); }
|
|
|
|
/*
|
|
Ifc4::IfcWorkScheduleTypeEnum::IfcWorkScheduleTypeEnum(const std::weak_ptr<InstanceData>& e)
|
|
: express::DeclaredType(e)
|
|
{}
|
|
|
|
Ifc4::IfcWorkScheduleTypeEnum::IfcWorkScheduleTypeEnum(Value v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), static_cast<size_t>(v)));
|
|
}
|
|
|
|
Ifc4::IfcWorkScheduleTypeEnum::IfcWorkScheduleTypeEnum(const std::string& v) {
|
|
set_attribute_value(0, EnumerationReference(&Class(), Class().lookup_enum_offset(v)));
|
|
}
|
|
*/
|
|
|
|
const char* Ifc4::IfcWorkScheduleTypeEnum::ToString(Value v) {
|
|
return Ifc4::IfcWorkScheduleTypeEnum::IfcWorkScheduleTypeEnum::Class().lookup_enum_value((size_t)v);
|
|
}
|
|
|
|
Ifc4::IfcWorkScheduleTypeEnum::Value Ifc4::IfcWorkScheduleTypeEnum::FromString(const std::string& s) {
|
|
return (Ifc4::IfcWorkScheduleTypeEnum::Value) Ifc4::IfcWorkScheduleTypeEnum::IfcWorkScheduleTypeEnum::Class().lookup_enum_offset(s);
|
|
}
|
|
|
|
Ifc4::IfcWorkScheduleTypeEnum::operator Ifc4::IfcWorkScheduleTypeEnum::Value() const {
|
|
return (Ifc4::IfcWorkScheduleTypeEnum::Value) ((EnumerationReference) get_attribute_value(0)).index();
|
|
}
|
|
|
|
const IfcParse::select_type& Ifc4::IfcActorSelect::Class() { return *((IfcParse::select_type*)IFC4_types[8]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcAppliedValueSelect::Class() { return *((IfcParse::select_type*)IFC4_types[37]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcAxis2Placement::Class() { return *((IfcParse::select_type*)IFC4_types[54]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcBendingParameterSelect::Class() { return *((IfcParse::select_type*)IFC4_types[62]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcBooleanOperand::Class() { return *((IfcParse::select_type*)IFC4_types[71]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcClassificationReferenceSelect::Class() { return *((IfcParse::select_type*)IFC4_types[143]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcClassificationSelect::Class() { return *((IfcParse::select_type*)IFC4_types[144]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcColour::Class() { return *((IfcParse::select_type*)IFC4_types[149]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcColourOrFactor::Class() { return *((IfcParse::select_type*)IFC4_types[150]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcCoordinateReferenceSystemSelect::Class() { return *((IfcParse::select_type*)IFC4_types[215]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcCsgSelect::Class() { return *((IfcParse::select_type*)IFC4_types[229]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcCurveFontOrScaledCurveFontSelect::Class() { return *((IfcParse::select_type*)IFC4_types[240]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcCurveOnSurface::Class() { return *((IfcParse::select_type*)IFC4_types[242]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcCurveOrEdgeCurve::Class() { return *((IfcParse::select_type*)IFC4_types[243]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcCurveStyleFontSelect::Class() { return *((IfcParse::select_type*)IFC4_types[248]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcDefinitionSelect::Class() { return *((IfcParse::select_type*)IFC4_types[258]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcDerivedMeasureValue::Class() { return *((IfcParse::select_type*)IFC4_types[259]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcDocumentSelect::Class() { return *((IfcParse::select_type*)IFC4_types[290]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcFillStyleSelect::Class() { return *((IfcParse::select_type*)IFC4_types[406]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcGeometricSetSelect::Class() { return *((IfcParse::select_type*)IFC4_types[457]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcGridPlacementDirectionSelect::Class() { return *((IfcParse::select_type*)IFC4_types[463]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcHatchLineDistanceSelect::Class() { return *((IfcParse::select_type*)IFC4_types[467]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcLayeredItem::Class() { return *((IfcParse::select_type*)IFC4_types[514]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcLibrarySelect::Class() { return *((IfcParse::select_type*)IFC4_types[519]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcLightDistributionDataSourceSelect::Class() { return *((IfcParse::select_type*)IFC4_types[522]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcMaterialSelect::Class() { return *((IfcParse::select_type*)IFC4_types[576]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcMeasureValue::Class() { return *((IfcParse::select_type*)IFC4_types[578]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcMetricValueSelect::Class() { return *((IfcParse::select_type*)IFC4_types[591]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcModulusOfRotationalSubgradeReactionSelect::Class() { return *((IfcParse::select_type*)IFC4_types[596]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcModulusOfSubgradeReactionSelect::Class() { return *((IfcParse::select_type*)IFC4_types[598]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcModulusOfTranslationalSubgradeReactionSelect::Class() { return *((IfcParse::select_type*)IFC4_types[599]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcObjectReferenceSelect::Class() { return *((IfcParse::select_type*)IFC4_types[619]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcPointOrVertexPoint::Class() { return *((IfcParse::select_type*)IFC4_types[678]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcPresentationStyleSelect::Class() { return *((IfcParse::select_type*)IFC4_types[703]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcProcessSelect::Class() { return *((IfcParse::select_type*)IFC4_types[709]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcProductRepresentationSelect::Class() { return *((IfcParse::select_type*)IFC4_types[713]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcProductSelect::Class() { return *((IfcParse::select_type*)IFC4_types[714]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcPropertySetDefinitionSelect::Class() { return *((IfcParse::select_type*)IFC4_types[737]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcResourceObjectSelect::Class() { return *((IfcParse::select_type*)IFC4_types[854]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcResourceSelect::Class() { return *((IfcParse::select_type*)IFC4_types[855]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcRotationalStiffnessSelect::Class() { return *((IfcParse::select_type*)IFC4_types[869]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcSegmentIndexSelect::Class() { return *((IfcParse::select_type*)IFC4_types[882]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcShell::Class() { return *((IfcParse::select_type*)IFC4_types[894]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcSimpleValue::Class() { return *((IfcParse::select_type*)IFC4_types[899]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcSizeSelect::Class() { return *((IfcParse::select_type*)IFC4_types[904]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcSolidOrShell::Class() { return *((IfcParse::select_type*)IFC4_types[916]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcSpaceBoundarySelect::Class() { return *((IfcParse::select_type*)IFC4_types[922]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcSpecularHighlightSelect::Class() { return *((IfcParse::select_type*)IFC4_types[937]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcStructuralActivityAssignmentSelect::Class() { return *((IfcParse::select_type*)IFC4_types[953]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcStyleAssignmentSelect::Class() { return *((IfcParse::select_type*)IFC4_types[993]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcSurfaceOrFaceSurface::Class() { return *((IfcParse::select_type*)IFC4_types[1008]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcSurfaceStyleElementSelect::Class() { return *((IfcParse::select_type*)IFC4_types[1012]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcTextFontSelect::Class() { return *((IfcParse::select_type*)IFC4_types[1057]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcTimeOrRatioSelect::Class() { return *((IfcParse::select_type*)IFC4_types[1079]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcTranslationalStiffnessSelect::Class() { return *((IfcParse::select_type*)IFC4_types[1093]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcTrimmingSelect::Class() { return *((IfcParse::select_type*)IFC4_types[1101]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcUnit::Class() { return *((IfcParse::select_type*)IFC4_types[1110]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcValue::Class() { return *((IfcParse::select_type*)IFC4_types[1121]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcVectorOrDirection::Class() { return *((IfcParse::select_type*)IFC4_types[1127]); }
|
|
|
|
const IfcParse::select_type& Ifc4::IfcWarpingStiffnessSelect::Class() { return *((IfcParse::select_type*)IFC4_types[1147]); }
|
|
|
|
|
|
// Function implementations for IfcAbsorbedDoseMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcAbsorbedDoseMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[0]); }
|
|
void Ifc4::IfcAbsorbedDoseMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcAbsorbedDoseMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcAccelerationMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcAccelerationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1]); }
|
|
void Ifc4::IfcAccelerationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcAccelerationMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcAmountOfSubstanceMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcAmountOfSubstanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[29]); }
|
|
void Ifc4::IfcAmountOfSubstanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcAmountOfSubstanceMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcAngularVelocityMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcAngularVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[32]); }
|
|
void Ifc4::IfcAngularVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcAngularVelocityMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcArcIndex
|
|
const IfcParse::type_declaration& Ifc4::IfcArcIndex::Class() { return *((IfcParse::type_declaration*)IFC4_types[43]); }
|
|
void Ifc4::IfcArcIndex::initialize(std::vector< int > /*[3:3]*/ v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcArcIndex::operator std::vector< int > /*[3:3]*/() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcAreaDensityMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcAreaDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[44]); }
|
|
void Ifc4::IfcAreaDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcAreaDensityMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcAreaMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcAreaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[45]); }
|
|
void Ifc4::IfcAreaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcAreaMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcBinary
|
|
const IfcParse::type_declaration& Ifc4::IfcBinary::Class() { return *((IfcParse::type_declaration*)IFC4_types[63]); }
|
|
void Ifc4::IfcBinary::initialize(boost::dynamic_bitset<> v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcBinary::operator boost::dynamic_bitset<>() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcBoolean
|
|
const IfcParse::type_declaration& Ifc4::IfcBoolean::Class() { return *((IfcParse::type_declaration*)IFC4_types[69]); }
|
|
void Ifc4::IfcBoolean::initialize(bool v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcBoolean::operator bool() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcBoxAlignment
|
|
const IfcParse::type_declaration& Ifc4::IfcBoxAlignment::Class() { return *((IfcParse::type_declaration*)IFC4_types[83]); }
|
|
void Ifc4::IfcBoxAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcBoxAlignment::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcCardinalPointReference
|
|
const IfcParse::type_declaration& Ifc4::IfcCardinalPointReference::Class() { return *((IfcParse::type_declaration*)IFC4_types[118]); }
|
|
void Ifc4::IfcCardinalPointReference::initialize(int v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcCardinalPointReference::operator int() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcComplexNumber
|
|
const IfcParse::type_declaration& Ifc4::IfcComplexNumber::Class() { return *((IfcParse::type_declaration*)IFC4_types[161]); }
|
|
void Ifc4::IfcComplexNumber::initialize(std::vector< double > /*[1:2]*/ v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcComplexNumber::operator std::vector< double > /*[1:2]*/() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcCompoundPlaneAngleMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcCompoundPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[169]); }
|
|
void Ifc4::IfcCompoundPlaneAngleMeasure::initialize(std::vector< int > /*[3:4]*/ v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcCompoundPlaneAngleMeasure::operator std::vector< int > /*[3:4]*/() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcContextDependentMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcContextDependentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[199]); }
|
|
void Ifc4::IfcContextDependentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcContextDependentMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcCountMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcCountMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[221]); }
|
|
void Ifc4::IfcCountMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcCountMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcCurvatureMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcCurvatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[236]); }
|
|
void Ifc4::IfcCurvatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcCurvatureMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcDate
|
|
const IfcParse::type_declaration& Ifc4::IfcDate::Class() { return *((IfcParse::type_declaration*)IFC4_types[254]); }
|
|
void Ifc4::IfcDate::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcDate::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcDateTime
|
|
const IfcParse::type_declaration& Ifc4::IfcDateTime::Class() { return *((IfcParse::type_declaration*)IFC4_types[255]); }
|
|
void Ifc4::IfcDateTime::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcDateTime::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcDayInMonthNumber
|
|
const IfcParse::type_declaration& Ifc4::IfcDayInMonthNumber::Class() { return *((IfcParse::type_declaration*)IFC4_types[256]); }
|
|
void Ifc4::IfcDayInMonthNumber::initialize(int v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcDayInMonthNumber::operator int() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcDayInWeekNumber
|
|
const IfcParse::type_declaration& Ifc4::IfcDayInWeekNumber::Class() { return *((IfcParse::type_declaration*)IFC4_types[257]); }
|
|
void Ifc4::IfcDayInWeekNumber::initialize(int v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcDayInWeekNumber::operator int() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcDescriptiveMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcDescriptiveMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[264]); }
|
|
void Ifc4::IfcDescriptiveMeasure::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcDescriptiveMeasure::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcDimensionCount
|
|
const IfcParse::type_declaration& Ifc4::IfcDimensionCount::Class() { return *((IfcParse::type_declaration*)IFC4_types[266]); }
|
|
void Ifc4::IfcDimensionCount::initialize(int v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcDimensionCount::operator int() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcDoseEquivalentMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcDoseEquivalentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[304]); }
|
|
void Ifc4::IfcDoseEquivalentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcDoseEquivalentMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcDuration
|
|
const IfcParse::type_declaration& Ifc4::IfcDuration::Class() { return *((IfcParse::type_declaration*)IFC4_types[316]); }
|
|
void Ifc4::IfcDuration::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcDuration::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcDynamicViscosityMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcDynamicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[317]); }
|
|
void Ifc4::IfcDynamicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcDynamicViscosityMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcElectricCapacitanceMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcElectricCapacitanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[324]); }
|
|
void Ifc4::IfcElectricCapacitanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcElectricCapacitanceMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcElectricChargeMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcElectricChargeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[325]); }
|
|
void Ifc4::IfcElectricChargeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcElectricChargeMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcElectricConductanceMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcElectricConductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[326]); }
|
|
void Ifc4::IfcElectricConductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcElectricConductanceMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcElectricCurrentMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcElectricCurrentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[327]); }
|
|
void Ifc4::IfcElectricCurrentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcElectricCurrentMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcElectricResistanceMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcElectricResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[340]); }
|
|
void Ifc4::IfcElectricResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcElectricResistanceMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcElectricVoltageMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcElectricVoltageMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[344]); }
|
|
void Ifc4::IfcElectricVoltageMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcElectricVoltageMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcEnergyMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcEnergyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[359]); }
|
|
void Ifc4::IfcEnergyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcEnergyMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcFontStyle
|
|
const IfcParse::type_declaration& Ifc4::IfcFontStyle::Class() { return *((IfcParse::type_declaration*)IFC4_types[435]); }
|
|
void Ifc4::IfcFontStyle::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcFontStyle::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcFontVariant
|
|
const IfcParse::type_declaration& Ifc4::IfcFontVariant::Class() { return *((IfcParse::type_declaration*)IFC4_types[436]); }
|
|
void Ifc4::IfcFontVariant::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcFontVariant::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcFontWeight
|
|
const IfcParse::type_declaration& Ifc4::IfcFontWeight::Class() { return *((IfcParse::type_declaration*)IFC4_types[437]); }
|
|
void Ifc4::IfcFontWeight::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcFontWeight::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcForceMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[441]); }
|
|
void Ifc4::IfcForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcForceMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcFrequencyMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[442]); }
|
|
void Ifc4::IfcFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcFrequencyMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcGloballyUniqueId
|
|
const IfcParse::type_declaration& Ifc4::IfcGloballyUniqueId::Class() { return *((IfcParse::type_declaration*)IFC4_types[458]); }
|
|
void Ifc4::IfcGloballyUniqueId::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcGloballyUniqueId::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcHeatFluxDensityMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcHeatFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[471]); }
|
|
void Ifc4::IfcHeatFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcHeatFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcHeatingValueMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcHeatingValueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[472]); }
|
|
void Ifc4::IfcHeatingValueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcHeatingValueMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcIdentifier
|
|
const IfcParse::type_declaration& Ifc4::IfcIdentifier::Class() { return *((IfcParse::type_declaration*)IFC4_types[476]); }
|
|
void Ifc4::IfcIdentifier::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcIdentifier::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcIlluminanceMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcIlluminanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[477]); }
|
|
void Ifc4::IfcIlluminanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcIlluminanceMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcInductanceMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcInductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[485]); }
|
|
void Ifc4::IfcInductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcInductanceMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcInteger
|
|
const IfcParse::type_declaration& Ifc4::IfcInteger::Class() { return *((IfcParse::type_declaration*)IFC4_types[486]); }
|
|
void Ifc4::IfcInteger::initialize(int v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcInteger::operator int() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcIntegerCountRateMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcIntegerCountRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[487]); }
|
|
void Ifc4::IfcIntegerCountRateMeasure::initialize(int v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcIntegerCountRateMeasure::operator int() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcIonConcentrationMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcIonConcentrationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[495]); }
|
|
void Ifc4::IfcIonConcentrationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcIonConcentrationMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcIsothermalMoistureCapacityMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcIsothermalMoistureCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[499]); }
|
|
void Ifc4::IfcIsothermalMoistureCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcIsothermalMoistureCapacityMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcKinematicViscosityMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcKinematicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[503]); }
|
|
void Ifc4::IfcKinematicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcKinematicViscosityMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcLabel
|
|
const IfcParse::type_declaration& Ifc4::IfcLabel::Class() { return *((IfcParse::type_declaration*)IFC4_types[505]); }
|
|
void Ifc4::IfcLabel::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcLabel::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcLanguageId
|
|
const IfcParse::type_declaration& Ifc4::IfcLanguageId::Class() { return *((IfcParse::type_declaration*)IFC4_types[513]); }
|
|
void Ifc4::IfcLanguageId::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcLanguageId::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcLengthMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[516]); }
|
|
void Ifc4::IfcLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcLengthMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcLineIndex
|
|
const IfcParse::type_declaration& Ifc4::IfcLineIndex::Class() { return *((IfcParse::type_declaration*)IFC4_types[539]); }
|
|
void Ifc4::IfcLineIndex::initialize(std::vector< int > /*[2:?]*/ v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcLineIndex::operator std::vector< int > /*[2:?]*/() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcLinearForceMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcLinearForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[535]); }
|
|
void Ifc4::IfcLinearForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcLinearForceMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcLinearMomentMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcLinearMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[536]); }
|
|
void Ifc4::IfcLinearMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcLinearMomentMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcLinearStiffnessMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcLinearStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[537]); }
|
|
void Ifc4::IfcLinearStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcLinearStiffnessMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcLinearVelocityMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcLinearVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[538]); }
|
|
void Ifc4::IfcLinearVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcLinearVelocityMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcLogical
|
|
const IfcParse::type_declaration& Ifc4::IfcLogical::Class() { return *((IfcParse::type_declaration*)IFC4_types[542]); }
|
|
void Ifc4::IfcLogical::initialize(boost::logic::tribool v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcLogical::operator boost::logic::tribool() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcLuminousFluxMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcLuminousFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[546]); }
|
|
void Ifc4::IfcLuminousFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcLuminousFluxMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcLuminousIntensityDistributionMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcLuminousIntensityDistributionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[547]); }
|
|
void Ifc4::IfcLuminousIntensityDistributionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcLuminousIntensityDistributionMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcLuminousIntensityMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcLuminousIntensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[548]); }
|
|
void Ifc4::IfcLuminousIntensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcLuminousIntensityMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcMagneticFluxDensityMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcMagneticFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[549]); }
|
|
void Ifc4::IfcMagneticFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcMagneticFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcMagneticFluxMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcMagneticFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[550]); }
|
|
void Ifc4::IfcMagneticFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcMagneticFluxMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcMassDensityMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcMassDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[554]); }
|
|
void Ifc4::IfcMassDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcMassDensityMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcMassFlowRateMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcMassFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[555]); }
|
|
void Ifc4::IfcMassFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcMassFlowRateMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcMassMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[556]); }
|
|
void Ifc4::IfcMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcMassMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcMassPerLengthMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcMassPerLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[557]); }
|
|
void Ifc4::IfcMassPerLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcMassPerLengthMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcModulusOfElasticityMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcModulusOfElasticityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[593]); }
|
|
void Ifc4::IfcModulusOfElasticityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcModulusOfElasticityMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcModulusOfLinearSubgradeReactionMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcModulusOfLinearSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[594]); }
|
|
void Ifc4::IfcModulusOfLinearSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcModulusOfLinearSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcModulusOfRotationalSubgradeReactionMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcModulusOfRotationalSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[595]); }
|
|
void Ifc4::IfcModulusOfRotationalSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcModulusOfRotationalSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcModulusOfSubgradeReactionMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcModulusOfSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[597]); }
|
|
void Ifc4::IfcModulusOfSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcModulusOfSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcMoistureDiffusivityMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcMoistureDiffusivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[600]); }
|
|
void Ifc4::IfcMoistureDiffusivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcMoistureDiffusivityMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcMolecularWeightMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcMolecularWeightMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[601]); }
|
|
void Ifc4::IfcMolecularWeightMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcMolecularWeightMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcMomentOfInertiaMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcMomentOfInertiaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[602]); }
|
|
void Ifc4::IfcMomentOfInertiaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcMomentOfInertiaMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcMonetaryMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcMonetaryMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[603]); }
|
|
void Ifc4::IfcMonetaryMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcMonetaryMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcMonthInYearNumber
|
|
const IfcParse::type_declaration& Ifc4::IfcMonthInYearNumber::Class() { return *((IfcParse::type_declaration*)IFC4_types[605]); }
|
|
void Ifc4::IfcMonthInYearNumber::initialize(int v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcMonthInYearNumber::operator int() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcNonNegativeLengthMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcNonNegativeLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[610]); }
|
|
void Ifc4::IfcNonNegativeLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcNonNegativeLengthMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcNormalisedRatioMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcNormalisedRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[611]); }
|
|
void Ifc4::IfcNormalisedRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcNormalisedRatioMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcNumericMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcNumericMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[613]); }
|
|
void Ifc4::IfcNumericMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcNumericMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcPHMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcPHMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[649]); }
|
|
void Ifc4::IfcPHMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcPHMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcParameterValue
|
|
const IfcParse::type_declaration& Ifc4::IfcParameterValue::Class() { return *((IfcParse::type_declaration*)IFC4_types[638]); }
|
|
void Ifc4::IfcParameterValue::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcParameterValue::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcPlanarForceMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcPlanarForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[668]); }
|
|
void Ifc4::IfcPlanarForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcPlanarForceMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcPlaneAngleMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[670]); }
|
|
void Ifc4::IfcPlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcPlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcPositiveInteger
|
|
const IfcParse::type_declaration& Ifc4::IfcPositiveInteger::Class() { return *((IfcParse::type_declaration*)IFC4_types[684]); }
|
|
void Ifc4::IfcPositiveInteger::initialize(int v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcPositiveInteger::operator int() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcPositiveLengthMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcPositiveLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[685]); }
|
|
void Ifc4::IfcPositiveLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcPositiveLengthMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcPositivePlaneAngleMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcPositivePlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[686]); }
|
|
void Ifc4::IfcPositivePlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcPositivePlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcPositiveRatioMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcPositiveRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[687]); }
|
|
void Ifc4::IfcPositiveRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcPositiveRatioMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcPowerMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[689]); }
|
|
void Ifc4::IfcPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcPowerMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcPresentableText
|
|
const IfcParse::type_declaration& Ifc4::IfcPresentableText::Class() { return *((IfcParse::type_declaration*)IFC4_types[697]); }
|
|
void Ifc4::IfcPresentableText::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcPresentableText::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcPressureMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[704]); }
|
|
void Ifc4::IfcPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcPressureMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcPropertySetDefinitionSet
|
|
const IfcParse::type_declaration& Ifc4::IfcPropertySetDefinitionSet::Class() { return *((IfcParse::type_declaration*)IFC4_types[738]); }
|
|
void Ifc4::IfcPropertySetDefinitionSet::initialize(std::vector< ::Ifc4::IfcPropertySetDefinition > v) { set_attribute_value(0, cast_vector<express::Base>(v)); }
|
|
Ifc4::IfcPropertySetDefinitionSet::operator std::vector< ::Ifc4::IfcPropertySetDefinition >() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcPropertySetDefinition>(es); }
|
|
|
|
// Function implementations for IfcRadioActivityMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcRadioActivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[762]); }
|
|
void Ifc4::IfcRadioActivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcRadioActivityMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcRatioMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[772]); }
|
|
void Ifc4::IfcRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcRatioMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcReal
|
|
const IfcParse::type_declaration& Ifc4::IfcReal::Class() { return *((IfcParse::type_declaration*)IFC4_types[775]); }
|
|
void Ifc4::IfcReal::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcReal::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcRotationalFrequencyMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcRotationalFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[866]); }
|
|
void Ifc4::IfcRotationalFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcRotationalFrequencyMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcRotationalMassMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcRotationalMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[867]); }
|
|
void Ifc4::IfcRotationalMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcRotationalMassMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcRotationalStiffnessMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcRotationalStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[868]); }
|
|
void Ifc4::IfcRotationalStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcRotationalStiffnessMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcSectionModulusMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcSectionModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[878]); }
|
|
void Ifc4::IfcSectionModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcSectionModulusMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcSectionalAreaIntegralMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcSectionalAreaIntegralMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[876]); }
|
|
void Ifc4::IfcSectionalAreaIntegralMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcSectionalAreaIntegralMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcShearModulusMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcShearModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[893]); }
|
|
void Ifc4::IfcShearModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcShearModulusMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcSolidAngleMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcSolidAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[914]); }
|
|
void Ifc4::IfcSolidAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcSolidAngleMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcSoundPowerLevelMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcSoundPowerLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[917]); }
|
|
void Ifc4::IfcSoundPowerLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcSoundPowerLevelMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcSoundPowerMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcSoundPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[918]); }
|
|
void Ifc4::IfcSoundPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcSoundPowerMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcSoundPressureLevelMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcSoundPressureLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[919]); }
|
|
void Ifc4::IfcSoundPressureLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcSoundPressureLevelMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcSoundPressureMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcSoundPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[920]); }
|
|
void Ifc4::IfcSoundPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcSoundPressureMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcSpecificHeatCapacityMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcSpecificHeatCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[935]); }
|
|
void Ifc4::IfcSpecificHeatCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcSpecificHeatCapacityMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcSpecularExponent
|
|
const IfcParse::type_declaration& Ifc4::IfcSpecularExponent::Class() { return *((IfcParse::type_declaration*)IFC4_types[936]); }
|
|
void Ifc4::IfcSpecularExponent::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcSpecularExponent::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcSpecularRoughness
|
|
const IfcParse::type_declaration& Ifc4::IfcSpecularRoughness::Class() { return *((IfcParse::type_declaration*)IFC4_types[938]); }
|
|
void Ifc4::IfcSpecularRoughness::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcSpecularRoughness::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcTemperatureGradientMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcTemperatureGradientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1043]); }
|
|
void Ifc4::IfcTemperatureGradientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcTemperatureGradientMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcTemperatureRateOfChangeMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcTemperatureRateOfChangeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1044]); }
|
|
void Ifc4::IfcTemperatureRateOfChangeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcTemperatureRateOfChangeMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcText
|
|
const IfcParse::type_declaration& Ifc4::IfcText::Class() { return *((IfcParse::type_declaration*)IFC4_types[1053]); }
|
|
void Ifc4::IfcText::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcText::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcTextAlignment
|
|
const IfcParse::type_declaration& Ifc4::IfcTextAlignment::Class() { return *((IfcParse::type_declaration*)IFC4_types[1054]); }
|
|
void Ifc4::IfcTextAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcTextAlignment::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcTextDecoration
|
|
const IfcParse::type_declaration& Ifc4::IfcTextDecoration::Class() { return *((IfcParse::type_declaration*)IFC4_types[1055]); }
|
|
void Ifc4::IfcTextDecoration::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcTextDecoration::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcTextFontName
|
|
const IfcParse::type_declaration& Ifc4::IfcTextFontName::Class() { return *((IfcParse::type_declaration*)IFC4_types[1056]); }
|
|
void Ifc4::IfcTextFontName::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcTextFontName::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcTextTransformation
|
|
const IfcParse::type_declaration& Ifc4::IfcTextTransformation::Class() { return *((IfcParse::type_declaration*)IFC4_types[1065]); }
|
|
void Ifc4::IfcTextTransformation::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcTextTransformation::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcThermalAdmittanceMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcThermalAdmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1071]); }
|
|
void Ifc4::IfcThermalAdmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcThermalAdmittanceMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcThermalConductivityMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcThermalConductivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1072]); }
|
|
void Ifc4::IfcThermalConductivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcThermalConductivityMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcThermalExpansionCoefficientMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcThermalExpansionCoefficientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1073]); }
|
|
void Ifc4::IfcThermalExpansionCoefficientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcThermalExpansionCoefficientMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcThermalResistanceMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcThermalResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1074]); }
|
|
void Ifc4::IfcThermalResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcThermalResistanceMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcThermalTransmittanceMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcThermalTransmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1075]); }
|
|
void Ifc4::IfcThermalTransmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcThermalTransmittanceMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcThermodynamicTemperatureMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcThermodynamicTemperatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1076]); }
|
|
void Ifc4::IfcThermodynamicTemperatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcThermodynamicTemperatureMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcTime
|
|
const IfcParse::type_declaration& Ifc4::IfcTime::Class() { return *((IfcParse::type_declaration*)IFC4_types[1077]); }
|
|
void Ifc4::IfcTime::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcTime::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcTimeMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcTimeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1078]); }
|
|
void Ifc4::IfcTimeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcTimeMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcTimeStamp
|
|
const IfcParse::type_declaration& Ifc4::IfcTimeStamp::Class() { return *((IfcParse::type_declaration*)IFC4_types[1084]); }
|
|
void Ifc4::IfcTimeStamp::initialize(int v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcTimeStamp::operator int() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcTorqueMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcTorqueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1088]); }
|
|
void Ifc4::IfcTorqueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcTorqueMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcURIReference
|
|
const IfcParse::type_declaration& Ifc4::IfcURIReference::Class() { return *((IfcParse::type_declaration*)IFC4_types[1119]); }
|
|
void Ifc4::IfcURIReference::initialize(std::string v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcURIReference::operator std::string() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcVaporPermeabilityMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcVaporPermeabilityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1125]); }
|
|
void Ifc4::IfcVaporPermeabilityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcVaporPermeabilityMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcVolumeMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcVolumeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1138]); }
|
|
void Ifc4::IfcVolumeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcVolumeMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcVolumetricFlowRateMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcVolumetricFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1139]); }
|
|
void Ifc4::IfcVolumetricFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcVolumetricFlowRateMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcWarpingConstantMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcWarpingConstantMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1145]); }
|
|
void Ifc4::IfcWarpingConstantMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcWarpingConstantMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
// Function implementations for IfcWarpingMomentMeasure
|
|
const IfcParse::type_declaration& Ifc4::IfcWarpingMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1146]); }
|
|
void Ifc4::IfcWarpingMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
|
|
Ifc4::IfcWarpingMomentMeasure::operator double() const { return get_attribute_value(0); }
|
|
|
|
|
|
// Function implementations for IfcActionRequest
|
|
std::optional< ::Ifc4::IfcActionRequestTypeEnum::Value > Ifc4::IfcActionRequest::PredefinedType() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } return ::Ifc4::IfcActionRequestTypeEnum::FromString(get_attribute_value(6)); }
|
|
void Ifc4::IfcActionRequest::setPredefinedType(const std::optional< ::Ifc4::IfcActionRequestTypeEnum::Value >& v) { if (v) {set_attribute_value(6, EnumerationReference(&::Ifc4::IfcActionRequestTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(6);} }
|
|
std::optional< std::string > Ifc4::IfcActionRequest::Status() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::string v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcActionRequest::setStatus(const std::optional< std::string >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< std::string > Ifc4::IfcActionRequest::LongDescription() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcActionRequest::setLongDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcActionRequest::Class() { return *((IfcParse::entity*)IFC4_types[2]); }
|
|
void Ifc4::IfcActionRequest::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< ::Ifc4::IfcActionRequestTypeEnum::Value > v7_PredefinedType, std::optional< std::string > v8_Status, std::optional< std::string > v9_LongDescription) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_PredefinedType) {set_attribute_value(6, (EnumerationReference(&::Ifc4::IfcActionRequestTypeEnum::Class(),(size_t)*v7_PredefinedType))); } if (v8_Status) {set_attribute_value(7, (*v8_Status)); } if (v9_LongDescription) {set_attribute_value(8, (*v9_LongDescription)); } }
|
|
|
|
// Function implementations for IfcActor
|
|
::Ifc4::IfcActorSelect Ifc4::IfcActor::TheActor() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcActorSelect>(); }
|
|
void Ifc4::IfcActor::setTheActor(const ::Ifc4::IfcActorSelect& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
std::vector<::Ifc4::IfcRelAssignsToActor> Ifc4::IfcActor::IsActingUpon() const { return cast_vector<IfcRelAssignsToActor>(file()->getInverse(data()->id(), IFC4_types[799], 6)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcActor::Class() { return *((IfcParse::entity*)IFC4_types[6]); }
|
|
void Ifc4::IfcActor::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcActorSelect v6_TheActor) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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)); }
|
|
|
|
// Function implementations for IfcActorRole
|
|
::Ifc4::IfcRoleEnum::Value Ifc4::IfcActorRole::Role() const { return ::Ifc4::IfcRoleEnum::FromString(get_attribute_value(0)); }
|
|
void Ifc4::IfcActorRole::setRole(const ::Ifc4::IfcRoleEnum::Value& v) { set_attribute_value(0, EnumerationReference(&::Ifc4::IfcRoleEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< std::string > Ifc4::IfcActorRole::UserDefinedRole() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcActorRole::setUserDefinedRole(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< std::string > Ifc4::IfcActorRole::Description() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcActorRole::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
|
|
std::vector<::Ifc4::IfcExternalReferenceRelationship> Ifc4::IfcActorRole::HasExternalReference() const { return cast_vector<IfcExternalReferenceRelationship>(file()->getInverse(data()->id(), IFC4_types[380], 3)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcActorRole::Class() { return *((IfcParse::entity*)IFC4_types[7]); }
|
|
void Ifc4::IfcActorRole::initialize(::Ifc4::IfcRoleEnum::Value v1_Role, std::optional< std::string > v2_UserDefinedRole, std::optional< std::string > v3_Description) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcRoleEnum::Class(),(size_t)v1_Role))); if (v2_UserDefinedRole) {set_attribute_value(1, (*v2_UserDefinedRole)); } if (v3_Description) {set_attribute_value(2, (*v3_Description)); } }
|
|
|
|
// Function implementations for IfcActuator
|
|
std::optional< ::Ifc4::IfcActuatorTypeEnum::Value > Ifc4::IfcActuator::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcActuatorTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcActuator::setPredefinedType(const std::optional< ::Ifc4::IfcActuatorTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcActuatorTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcActuator::Class() { return *((IfcParse::entity*)IFC4_types[9]); }
|
|
void Ifc4::IfcActuator::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcActuatorTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcActuatorTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcActuatorType
|
|
::Ifc4::IfcActuatorTypeEnum::Value Ifc4::IfcActuatorType::PredefinedType() const { return ::Ifc4::IfcActuatorTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcActuatorType::setPredefinedType(const ::Ifc4::IfcActuatorTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcActuatorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcActuatorType::Class() { return *((IfcParse::entity*)IFC4_types[10]); }
|
|
void Ifc4::IfcActuatorType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcActuatorTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcActuatorTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcAddress
|
|
std::optional< ::Ifc4::IfcAddressTypeEnum::Value > Ifc4::IfcAddress::Purpose() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } return ::Ifc4::IfcAddressTypeEnum::FromString(get_attribute_value(0)); }
|
|
void Ifc4::IfcAddress::setPurpose(const std::optional< ::Ifc4::IfcAddressTypeEnum::Value >& v) { if (v) {set_attribute_value(0, EnumerationReference(&::Ifc4::IfcAddressTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(0);} }
|
|
std::optional< std::string > Ifc4::IfcAddress::Description() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcAddress::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< std::string > Ifc4::IfcAddress::UserDefinedPurpose() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcAddress::setUserDefinedPurpose(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
|
|
std::vector<::Ifc4::IfcPerson> Ifc4::IfcAddress::OfPerson() const { return cast_vector<IfcPerson>(file()->getInverse(data()->id(), IFC4_types[647], 7)); }
|
|
std::vector<::Ifc4::IfcOrganization> Ifc4::IfcAddress::OfOrganization() const { return cast_vector<IfcOrganization>(file()->getInverse(data()->id(), IFC4_types[629], 4)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcAddress::Class() { return *((IfcParse::entity*)IFC4_types[12]); }
|
|
void Ifc4::IfcAddress::initialize(std::optional< ::Ifc4::IfcAddressTypeEnum::Value > v1_Purpose, std::optional< std::string > v2_Description, std::optional< std::string > v3_UserDefinedPurpose) { if (v1_Purpose) {set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcAddressTypeEnum::Class(),(size_t)*v1_Purpose))); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); } if (v3_UserDefinedPurpose) {set_attribute_value(2, (*v3_UserDefinedPurpose)); } }
|
|
|
|
// Function implementations for IfcAdvancedBrep
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAdvancedBrep::Class() { return *((IfcParse::entity*)IFC4_types[14]); }
|
|
void Ifc4::IfcAdvancedBrep::initialize(::Ifc4::IfcClosedShell v1_Outer) { set_attribute_value(0, (v1_Outer)); }
|
|
|
|
// Function implementations for IfcAdvancedBrepWithVoids
|
|
std::vector< ::Ifc4::IfcClosedShell > Ifc4::IfcAdvancedBrepWithVoids::Voids() const { std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcClosedShell>(es); }
|
|
void Ifc4::IfcAdvancedBrepWithVoids::setVoids(const std::vector< ::Ifc4::IfcClosedShell >& v) { set_attribute_value(1, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAdvancedBrepWithVoids::Class() { return *((IfcParse::entity*)IFC4_types[15]); }
|
|
void Ifc4::IfcAdvancedBrepWithVoids::initialize(::Ifc4::IfcClosedShell v1_Outer, std::vector< ::Ifc4::IfcClosedShell > v2_Voids) { set_attribute_value(0, (v1_Outer));set_attribute_value(1, cast_vector<express::Base>(v2_Voids)); }
|
|
|
|
// Function implementations for IfcAdvancedFace
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAdvancedFace::Class() { return *((IfcParse::entity*)IFC4_types[16]); }
|
|
void Ifc4::IfcAdvancedFace::initialize(std::vector< ::Ifc4::IfcFaceBound > v1_Bounds, ::Ifc4::IfcSurface v2_FaceSurface, bool v3_SameSense) { set_attribute_value(0, cast_vector<express::Base>(v1_Bounds));set_attribute_value(1, (v2_FaceSurface));set_attribute_value(2, (v3_SameSense)); }
|
|
|
|
// Function implementations for IfcAirTerminal
|
|
std::optional< ::Ifc4::IfcAirTerminalTypeEnum::Value > Ifc4::IfcAirTerminal::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcAirTerminalTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcAirTerminal::setPredefinedType(const std::optional< ::Ifc4::IfcAirTerminalTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcAirTerminalTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAirTerminal::Class() { return *((IfcParse::entity*)IFC4_types[17]); }
|
|
void Ifc4::IfcAirTerminal::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcAirTerminalTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcAirTerminalTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcAirTerminalBox
|
|
std::optional< ::Ifc4::IfcAirTerminalBoxTypeEnum::Value > Ifc4::IfcAirTerminalBox::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcAirTerminalBoxTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcAirTerminalBox::setPredefinedType(const std::optional< ::Ifc4::IfcAirTerminalBoxTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcAirTerminalBoxTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAirTerminalBox::Class() { return *((IfcParse::entity*)IFC4_types[18]); }
|
|
void Ifc4::IfcAirTerminalBox::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcAirTerminalBoxTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcAirTerminalBoxTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcAirTerminalBoxType
|
|
::Ifc4::IfcAirTerminalBoxTypeEnum::Value Ifc4::IfcAirTerminalBoxType::PredefinedType() const { return ::Ifc4::IfcAirTerminalBoxTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcAirTerminalBoxType::setPredefinedType(const ::Ifc4::IfcAirTerminalBoxTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcAirTerminalBoxTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAirTerminalBoxType::Class() { return *((IfcParse::entity*)IFC4_types[19]); }
|
|
void Ifc4::IfcAirTerminalBoxType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcAirTerminalBoxTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcAirTerminalBoxTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcAirTerminalType
|
|
::Ifc4::IfcAirTerminalTypeEnum::Value Ifc4::IfcAirTerminalType::PredefinedType() const { return ::Ifc4::IfcAirTerminalTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcAirTerminalType::setPredefinedType(const ::Ifc4::IfcAirTerminalTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcAirTerminalTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAirTerminalType::Class() { return *((IfcParse::entity*)IFC4_types[21]); }
|
|
void Ifc4::IfcAirTerminalType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcAirTerminalTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcAirTerminalTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcAirToAirHeatRecovery
|
|
std::optional< ::Ifc4::IfcAirToAirHeatRecoveryTypeEnum::Value > Ifc4::IfcAirToAirHeatRecovery::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcAirToAirHeatRecoveryTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcAirToAirHeatRecovery::setPredefinedType(const std::optional< ::Ifc4::IfcAirToAirHeatRecoveryTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcAirToAirHeatRecoveryTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAirToAirHeatRecovery::Class() { return *((IfcParse::entity*)IFC4_types[23]); }
|
|
void Ifc4::IfcAirToAirHeatRecovery::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcAirToAirHeatRecoveryTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcAirToAirHeatRecoveryTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcAirToAirHeatRecoveryType
|
|
::Ifc4::IfcAirToAirHeatRecoveryTypeEnum::Value Ifc4::IfcAirToAirHeatRecoveryType::PredefinedType() const { return ::Ifc4::IfcAirToAirHeatRecoveryTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcAirToAirHeatRecoveryType::setPredefinedType(const ::Ifc4::IfcAirToAirHeatRecoveryTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcAirToAirHeatRecoveryTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAirToAirHeatRecoveryType::Class() { return *((IfcParse::entity*)IFC4_types[24]); }
|
|
void Ifc4::IfcAirToAirHeatRecoveryType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcAirToAirHeatRecoveryTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcAirToAirHeatRecoveryTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcAlarm
|
|
std::optional< ::Ifc4::IfcAlarmTypeEnum::Value > Ifc4::IfcAlarm::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcAlarmTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcAlarm::setPredefinedType(const std::optional< ::Ifc4::IfcAlarmTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcAlarmTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAlarm::Class() { return *((IfcParse::entity*)IFC4_types[26]); }
|
|
void Ifc4::IfcAlarm::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcAlarmTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcAlarmTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcAlarmType
|
|
::Ifc4::IfcAlarmTypeEnum::Value Ifc4::IfcAlarmType::PredefinedType() const { return ::Ifc4::IfcAlarmTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcAlarmType::setPredefinedType(const ::Ifc4::IfcAlarmTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcAlarmTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAlarmType::Class() { return *((IfcParse::entity*)IFC4_types[27]); }
|
|
void Ifc4::IfcAlarmType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcAlarmTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcAlarmTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcAnnotation
|
|
|
|
std::vector<::Ifc4::IfcRelContainedInSpatialStructure> Ifc4::IfcAnnotation::ContainedInStructure() const { return cast_vector<IfcRelContainedInSpatialStructure>(file()->getInverse(data()->id(), IFC4_types[823], 4)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcAnnotation::Class() { return *((IfcParse::entity*)IFC4_types[33]); }
|
|
void Ifc4::IfcAnnotation::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); }
|
|
|
|
// Function implementations for IfcAnnotationFillArea
|
|
::Ifc4::IfcCurve Ifc4::IfcAnnotationFillArea::OuterBoundary() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcCurve>(); }
|
|
void Ifc4::IfcAnnotationFillArea::setOuterBoundary(const ::Ifc4::IfcCurve& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< std::vector< ::Ifc4::IfcCurve > > Ifc4::IfcAnnotationFillArea::InnerBoundaries() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcCurve>(es); }
|
|
void Ifc4::IfcAnnotationFillArea::setInnerBoundaries(const std::optional< std::vector< ::Ifc4::IfcCurve > >& v) { if (v) {set_attribute_value(1, cast_vector<express::Base>(*v));} else {unset_attribute_value(1);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAnnotationFillArea::Class() { return *((IfcParse::entity*)IFC4_types[34]); }
|
|
void Ifc4::IfcAnnotationFillArea::initialize(::Ifc4::IfcCurve v1_OuterBoundary, std::optional< std::vector< ::Ifc4::IfcCurve > > v2_InnerBoundaries) { set_attribute_value(0, (v1_OuterBoundary)); if (v2_InnerBoundaries) {set_attribute_value(1, cast_vector<express::Base>(*v2_InnerBoundaries)); } }
|
|
|
|
// Function implementations for IfcApplication
|
|
::Ifc4::IfcOrganization Ifc4::IfcApplication::ApplicationDeveloper() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcOrganization>(); }
|
|
void Ifc4::IfcApplication::setApplicationDeveloper(const ::Ifc4::IfcOrganization& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::string Ifc4::IfcApplication::Version() const { std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcApplication::setVersion(const std::string& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
std::string Ifc4::IfcApplication::ApplicationFullName() const { std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcApplication::setApplicationFullName(const std::string& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
std::string Ifc4::IfcApplication::ApplicationIdentifier() const { std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcApplication::setApplicationIdentifier(const std::string& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcApplication::Class() { return *((IfcParse::entity*)IFC4_types[35]); }
|
|
void Ifc4::IfcApplication::initialize(::Ifc4::IfcOrganization v1_ApplicationDeveloper, std::string v2_Version, std::string v3_ApplicationFullName, std::string v4_ApplicationIdentifier) { set_attribute_value(0, (v1_ApplicationDeveloper));set_attribute_value(1, (v2_Version));set_attribute_value(2, (v3_ApplicationFullName));set_attribute_value(3, (v4_ApplicationIdentifier)); }
|
|
|
|
// Function implementations for IfcAppliedValue
|
|
std::optional< std::string > Ifc4::IfcAppliedValue::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcAppliedValue::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< std::string > Ifc4::IfcAppliedValue::Description() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcAppliedValue::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
::Ifc4::IfcAppliedValueSelect Ifc4::IfcAppliedValue::AppliedValue() const { if(get_attribute_value(2).isNull()) { return ::Ifc4::IfcAppliedValueSelect{}; } return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcAppliedValueSelect>(); }
|
|
void Ifc4::IfcAppliedValue::setAppliedValue(const ::Ifc4::IfcAppliedValueSelect& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcMeasureWithUnit Ifc4::IfcAppliedValue::UnitBasis() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcMeasureWithUnit{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcMeasureWithUnit>(); }
|
|
void Ifc4::IfcAppliedValue::setUnitBasis(const ::Ifc4::IfcMeasureWithUnit& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< std::string > Ifc4::IfcAppliedValue::ApplicableDate() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcAppliedValue::setApplicableDate(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcAppliedValue::FixedUntilDate() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcAppliedValue::setFixedUntilDate(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< std::string > Ifc4::IfcAppliedValue::Category() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcAppliedValue::setCategory(const std::optional< std::string >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
std::optional< std::string > Ifc4::IfcAppliedValue::Condition() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::string v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcAppliedValue::setCondition(const std::optional< std::string >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< ::Ifc4::IfcArithmeticOperatorEnum::Value > Ifc4::IfcAppliedValue::ArithmeticOperator() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcArithmeticOperatorEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcAppliedValue::setArithmeticOperator(const std::optional< ::Ifc4::IfcArithmeticOperatorEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcArithmeticOperatorEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
std::optional< std::vector< ::Ifc4::IfcAppliedValue > > Ifc4::IfcAppliedValue::Components() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(9); return cast_vector<::Ifc4::IfcAppliedValue>(es); }
|
|
void Ifc4::IfcAppliedValue::setComponents(const std::optional< std::vector< ::Ifc4::IfcAppliedValue > >& v) { if (v) {set_attribute_value(9, cast_vector<express::Base>(*v));} else {unset_attribute_value(9);} }
|
|
|
|
std::vector<::Ifc4::IfcExternalReferenceRelationship> Ifc4::IfcAppliedValue::HasExternalReference() const { return cast_vector<IfcExternalReferenceRelationship>(file()->getInverse(data()->id(), IFC4_types[380], 3)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcAppliedValue::Class() { return *((IfcParse::entity*)IFC4_types[36]); }
|
|
void Ifc4::IfcAppliedValue::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcAppliedValueSelect v3_AppliedValue, ::Ifc4::IfcMeasureWithUnit v4_UnitBasis, std::optional< std::string > v5_ApplicableDate, std::optional< std::string > v6_FixedUntilDate, std::optional< std::string > v7_Category, std::optional< std::string > v8_Condition, std::optional< ::Ifc4::IfcArithmeticOperatorEnum::Value > v9_ArithmeticOperator, std::optional< std::vector< ::Ifc4::IfcAppliedValue > > v10_Components) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_AppliedValue));set_attribute_value(3, (v4_UnitBasis)); if (v5_ApplicableDate) {set_attribute_value(4, (*v5_ApplicableDate)); } if (v6_FixedUntilDate) {set_attribute_value(5, (*v6_FixedUntilDate)); } if (v7_Category) {set_attribute_value(6, (*v7_Category)); } if (v8_Condition) {set_attribute_value(7, (*v8_Condition)); } if (v9_ArithmeticOperator) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcArithmeticOperatorEnum::Class(),(size_t)*v9_ArithmeticOperator))); } if (v10_Components) {set_attribute_value(9, cast_vector<express::Base>(*v10_Components)); } }
|
|
|
|
// Function implementations for IfcApproval
|
|
std::optional< std::string > Ifc4::IfcApproval::Identifier() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcApproval::setIdentifier(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< std::string > Ifc4::IfcApproval::Name() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcApproval::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< std::string > Ifc4::IfcApproval::Description() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcApproval::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< std::string > Ifc4::IfcApproval::TimeOfApproval() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcApproval::setTimeOfApproval(const std::optional< std::string >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< std::string > Ifc4::IfcApproval::Status() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcApproval::setStatus(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcApproval::Level() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcApproval::setLevel(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< std::string > Ifc4::IfcApproval::Qualifier() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcApproval::setQualifier(const std::optional< std::string >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
::Ifc4::IfcActorSelect Ifc4::IfcApproval::RequestingApproval() const { if(get_attribute_value(7).isNull()) { return ::Ifc4::IfcActorSelect{}; } return ((express::Base)(get_attribute_value(7))).as<::Ifc4::IfcActorSelect>(); }
|
|
void Ifc4::IfcApproval::setRequestingApproval(const ::Ifc4::IfcActorSelect& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
::Ifc4::IfcActorSelect Ifc4::IfcApproval::GivingApproval() const { if(get_attribute_value(8).isNull()) { return ::Ifc4::IfcActorSelect{}; } return ((express::Base)(get_attribute_value(8))).as<::Ifc4::IfcActorSelect>(); }
|
|
void Ifc4::IfcApproval::setGivingApproval(const ::Ifc4::IfcActorSelect& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
|
|
std::vector<::Ifc4::IfcExternalReferenceRelationship> Ifc4::IfcApproval::HasExternalReferences() const { return cast_vector<IfcExternalReferenceRelationship>(file()->getInverse(data()->id(), IFC4_types[380], 3)); }
|
|
std::vector<::Ifc4::IfcRelAssociatesApproval> Ifc4::IfcApproval::ApprovedObjects() const { return cast_vector<IfcRelAssociatesApproval>(file()->getInverse(data()->id(), IFC4_types[807], 5)); }
|
|
std::vector<::Ifc4::IfcResourceApprovalRelationship> Ifc4::IfcApproval::ApprovedResources() const { return cast_vector<IfcResourceApprovalRelationship>(file()->getInverse(data()->id(), IFC4_types[851], 3)); }
|
|
std::vector<::Ifc4::IfcApprovalRelationship> Ifc4::IfcApproval::IsRelatedWith() const { return cast_vector<IfcApprovalRelationship>(file()->getInverse(data()->id(), IFC4_types[39], 3)); }
|
|
std::vector<::Ifc4::IfcApprovalRelationship> Ifc4::IfcApproval::Relates() const { return cast_vector<IfcApprovalRelationship>(file()->getInverse(data()->id(), IFC4_types[39], 2)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcApproval::Class() { return *((IfcParse::entity*)IFC4_types[38]); }
|
|
void Ifc4::IfcApproval::initialize(std::optional< std::string > v1_Identifier, std::optional< std::string > v2_Name, std::optional< std::string > v3_Description, std::optional< std::string > v4_TimeOfApproval, std::optional< std::string > v5_Status, std::optional< std::string > v6_Level, std::optional< std::string > v7_Qualifier, ::Ifc4::IfcActorSelect v8_RequestingApproval, ::Ifc4::IfcActorSelect v9_GivingApproval) { if (v1_Identifier) {set_attribute_value(0, (*v1_Identifier)); } if (v2_Name) {set_attribute_value(1, (*v2_Name)); } if (v3_Description) {set_attribute_value(2, (*v3_Description)); } if (v4_TimeOfApproval) {set_attribute_value(3, (*v4_TimeOfApproval)); } if (v5_Status) {set_attribute_value(4, (*v5_Status)); } if (v6_Level) {set_attribute_value(5, (*v6_Level)); } if (v7_Qualifier) {set_attribute_value(6, (*v7_Qualifier)); }set_attribute_value(7, (v8_RequestingApproval));set_attribute_value(8, (v9_GivingApproval)); }
|
|
|
|
// Function implementations for IfcApprovalRelationship
|
|
::Ifc4::IfcApproval Ifc4::IfcApprovalRelationship::RelatingApproval() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcApproval>(); }
|
|
void Ifc4::IfcApprovalRelationship::setRelatingApproval(const ::Ifc4::IfcApproval& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
std::vector< ::Ifc4::IfcApproval > Ifc4::IfcApprovalRelationship::RelatedApprovals() const { std::vector<express::Base> es = get_attribute_value(3); return cast_vector<::Ifc4::IfcApproval>(es); }
|
|
void Ifc4::IfcApprovalRelationship::setRelatedApprovals(const std::vector< ::Ifc4::IfcApproval >& v) { set_attribute_value(3, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcApprovalRelationship::Class() { return *((IfcParse::entity*)IFC4_types[39]); }
|
|
void Ifc4::IfcApprovalRelationship::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcApproval v3_RelatingApproval, std::vector< ::Ifc4::IfcApproval > v4_RelatedApprovals) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_RelatingApproval));set_attribute_value(3, cast_vector<express::Base>(v4_RelatedApprovals)); }
|
|
|
|
// Function implementations for IfcArbitraryClosedProfileDef
|
|
::Ifc4::IfcCurve Ifc4::IfcArbitraryClosedProfileDef::OuterCurve() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcCurve>(); }
|
|
void Ifc4::IfcArbitraryClosedProfileDef::setOuterCurve(const ::Ifc4::IfcCurve& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcArbitraryClosedProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[40]); }
|
|
void Ifc4::IfcArbitraryClosedProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcCurve v3_OuterCurve) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_OuterCurve)); }
|
|
|
|
// Function implementations for IfcArbitraryOpenProfileDef
|
|
::Ifc4::IfcBoundedCurve Ifc4::IfcArbitraryOpenProfileDef::Curve() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcBoundedCurve>(); }
|
|
void Ifc4::IfcArbitraryOpenProfileDef::setCurve(const ::Ifc4::IfcBoundedCurve& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcArbitraryOpenProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[41]); }
|
|
void Ifc4::IfcArbitraryOpenProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcBoundedCurve v3_Curve) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Curve)); }
|
|
|
|
// Function implementations for IfcArbitraryProfileDefWithVoids
|
|
std::vector< ::Ifc4::IfcCurve > Ifc4::IfcArbitraryProfileDefWithVoids::InnerCurves() const { std::vector<express::Base> es = get_attribute_value(3); return cast_vector<::Ifc4::IfcCurve>(es); }
|
|
void Ifc4::IfcArbitraryProfileDefWithVoids::setInnerCurves(const std::vector< ::Ifc4::IfcCurve >& v) { set_attribute_value(3, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcArbitraryProfileDefWithVoids::Class() { return *((IfcParse::entity*)IFC4_types[42]); }
|
|
void Ifc4::IfcArbitraryProfileDefWithVoids::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcCurve v3_OuterCurve, std::vector< ::Ifc4::IfcCurve > v4_InnerCurves) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_OuterCurve));set_attribute_value(3, cast_vector<express::Base>(v4_InnerCurves)); }
|
|
|
|
// Function implementations for IfcAsset
|
|
std::optional< std::string > Ifc4::IfcAsset::Identification() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcAsset::setIdentification(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
::Ifc4::IfcCostValue Ifc4::IfcAsset::OriginalValue() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcCostValue{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcCostValue>(); }
|
|
void Ifc4::IfcAsset::setOriginalValue(const ::Ifc4::IfcCostValue& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
::Ifc4::IfcCostValue Ifc4::IfcAsset::CurrentValue() const { if(get_attribute_value(7).isNull()) { return ::Ifc4::IfcCostValue{}; } return ((express::Base)(get_attribute_value(7))).as<::Ifc4::IfcCostValue>(); }
|
|
void Ifc4::IfcAsset::setCurrentValue(const ::Ifc4::IfcCostValue& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
::Ifc4::IfcCostValue Ifc4::IfcAsset::TotalReplacementCost() const { if(get_attribute_value(8).isNull()) { return ::Ifc4::IfcCostValue{}; } return ((express::Base)(get_attribute_value(8))).as<::Ifc4::IfcCostValue>(); }
|
|
void Ifc4::IfcAsset::setTotalReplacementCost(const ::Ifc4::IfcCostValue& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
::Ifc4::IfcActorSelect Ifc4::IfcAsset::Owner() const { if(get_attribute_value(9).isNull()) { return ::Ifc4::IfcActorSelect{}; } return ((express::Base)(get_attribute_value(9))).as<::Ifc4::IfcActorSelect>(); }
|
|
void Ifc4::IfcAsset::setOwner(const ::Ifc4::IfcActorSelect& v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }
|
|
::Ifc4::IfcActorSelect Ifc4::IfcAsset::User() const { if(get_attribute_value(10).isNull()) { return ::Ifc4::IfcActorSelect{}; } return ((express::Base)(get_attribute_value(10))).as<::Ifc4::IfcActorSelect>(); }
|
|
void Ifc4::IfcAsset::setUser(const ::Ifc4::IfcActorSelect& v) { set_attribute_value(10, v);if constexpr (false)unset_attribute_value(10); }
|
|
::Ifc4::IfcPerson Ifc4::IfcAsset::ResponsiblePerson() const { if(get_attribute_value(11).isNull()) { return ::Ifc4::IfcPerson{}; } return ((express::Base)(get_attribute_value(11))).as<::Ifc4::IfcPerson>(); }
|
|
void Ifc4::IfcAsset::setResponsiblePerson(const ::Ifc4::IfcPerson& v) { set_attribute_value(11, v);if constexpr (false)unset_attribute_value(11); }
|
|
std::optional< std::string > Ifc4::IfcAsset::IncorporationDate() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } std::string v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcAsset::setIncorporationDate(const std::optional< std::string >& v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
|
|
::Ifc4::IfcCostValue Ifc4::IfcAsset::DepreciatedValue() const { if(get_attribute_value(13).isNull()) { return ::Ifc4::IfcCostValue{}; } return ((express::Base)(get_attribute_value(13))).as<::Ifc4::IfcCostValue>(); }
|
|
void Ifc4::IfcAsset::setDepreciatedValue(const ::Ifc4::IfcCostValue& v) { set_attribute_value(13, v);if constexpr (false)unset_attribute_value(13); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAsset::Class() { return *((IfcParse::entity*)IFC4_types[48]); }
|
|
void Ifc4::IfcAsset::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, ::Ifc4::IfcCostValue v7_OriginalValue, ::Ifc4::IfcCostValue v8_CurrentValue, ::Ifc4::IfcCostValue v9_TotalReplacementCost, ::Ifc4::IfcActorSelect v10_Owner, ::Ifc4::IfcActorSelect v11_User, ::Ifc4::IfcPerson v12_ResponsiblePerson, std::optional< std::string > v13_IncorporationDate, ::Ifc4::IfcCostValue v14_DepreciatedValue) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); }set_attribute_value(6, (v7_OriginalValue));set_attribute_value(7, (v8_CurrentValue));set_attribute_value(8, (v9_TotalReplacementCost));set_attribute_value(9, (v10_Owner));set_attribute_value(10, (v11_User));set_attribute_value(11, (v12_ResponsiblePerson)); if (v13_IncorporationDate) {set_attribute_value(12, (*v13_IncorporationDate)); }set_attribute_value(13, (v14_DepreciatedValue)); }
|
|
|
|
// Function implementations for IfcAsymmetricIShapeProfileDef
|
|
double Ifc4::IfcAsymmetricIShapeProfileDef::BottomFlangeWidth() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcAsymmetricIShapeProfileDef::setBottomFlangeWidth(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
double Ifc4::IfcAsymmetricIShapeProfileDef::OverallDepth() const { double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcAsymmetricIShapeProfileDef::setOverallDepth(const double& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
double Ifc4::IfcAsymmetricIShapeProfileDef::WebThickness() const { double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcAsymmetricIShapeProfileDef::setWebThickness(const double& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
double Ifc4::IfcAsymmetricIShapeProfileDef::BottomFlangeThickness() const { double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcAsymmetricIShapeProfileDef::setBottomFlangeThickness(const double& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
std::optional< double > Ifc4::IfcAsymmetricIShapeProfileDef::BottomFlangeFilletRadius() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcAsymmetricIShapeProfileDef::setBottomFlangeFilletRadius(const std::optional< double >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
double Ifc4::IfcAsymmetricIShapeProfileDef::TopFlangeWidth() const { double v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcAsymmetricIShapeProfileDef::setTopFlangeWidth(const double& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
std::optional< double > Ifc4::IfcAsymmetricIShapeProfileDef::TopFlangeThickness() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } double v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcAsymmetricIShapeProfileDef::setTopFlangeThickness(const std::optional< double >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
std::optional< double > Ifc4::IfcAsymmetricIShapeProfileDef::TopFlangeFilletRadius() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } double v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcAsymmetricIShapeProfileDef::setTopFlangeFilletRadius(const std::optional< double >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::optional< double > Ifc4::IfcAsymmetricIShapeProfileDef::BottomFlangeEdgeRadius() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } double v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcAsymmetricIShapeProfileDef::setBottomFlangeEdgeRadius(const std::optional< double >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
std::optional< double > Ifc4::IfcAsymmetricIShapeProfileDef::BottomFlangeSlope() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } double v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcAsymmetricIShapeProfileDef::setBottomFlangeSlope(const std::optional< double >& v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
|
|
std::optional< double > Ifc4::IfcAsymmetricIShapeProfileDef::TopFlangeEdgeRadius() const { if(get_attribute_value(13).isNull()) { return std::nullopt; } double v = get_attribute_value(13); return v; }
|
|
void Ifc4::IfcAsymmetricIShapeProfileDef::setTopFlangeEdgeRadius(const std::optional< double >& v) { if (v) {set_attribute_value(13, *v);} else {unset_attribute_value(13);} }
|
|
std::optional< double > Ifc4::IfcAsymmetricIShapeProfileDef::TopFlangeSlope() const { if(get_attribute_value(14).isNull()) { return std::nullopt; } double v = get_attribute_value(14); return v; }
|
|
void Ifc4::IfcAsymmetricIShapeProfileDef::setTopFlangeSlope(const std::optional< double >& v) { if (v) {set_attribute_value(14, *v);} else {unset_attribute_value(14);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAsymmetricIShapeProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[49]); }
|
|
void Ifc4::IfcAsymmetricIShapeProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcAxis2Placement2D v3_Position, double v4_BottomFlangeWidth, double v5_OverallDepth, double v6_WebThickness, double v7_BottomFlangeThickness, std::optional< double > v8_BottomFlangeFilletRadius, double v9_TopFlangeWidth, std::optional< double > v10_TopFlangeThickness, std::optional< double > v11_TopFlangeFilletRadius, std::optional< double > v12_BottomFlangeEdgeRadius, std::optional< double > v13_BottomFlangeSlope, std::optional< double > v14_TopFlangeEdgeRadius, std::optional< double > v15_TopFlangeSlope) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Position));set_attribute_value(3, (v4_BottomFlangeWidth));set_attribute_value(4, (v5_OverallDepth));set_attribute_value(5, (v6_WebThickness));set_attribute_value(6, (v7_BottomFlangeThickness)); if (v8_BottomFlangeFilletRadius) {set_attribute_value(7, (*v8_BottomFlangeFilletRadius)); }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_BottomFlangeEdgeRadius) {set_attribute_value(11, (*v12_BottomFlangeEdgeRadius)); } if (v13_BottomFlangeSlope) {set_attribute_value(12, (*v13_BottomFlangeSlope)); } if (v14_TopFlangeEdgeRadius) {set_attribute_value(13, (*v14_TopFlangeEdgeRadius)); } if (v15_TopFlangeSlope) {set_attribute_value(14, (*v15_TopFlangeSlope)); } }
|
|
|
|
// Function implementations for IfcAudioVisualAppliance
|
|
std::optional< ::Ifc4::IfcAudioVisualApplianceTypeEnum::Value > Ifc4::IfcAudioVisualAppliance::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcAudioVisualApplianceTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcAudioVisualAppliance::setPredefinedType(const std::optional< ::Ifc4::IfcAudioVisualApplianceTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcAudioVisualApplianceTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAudioVisualAppliance::Class() { return *((IfcParse::entity*)IFC4_types[50]); }
|
|
void Ifc4::IfcAudioVisualAppliance::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcAudioVisualApplianceTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcAudioVisualApplianceTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcAudioVisualApplianceType
|
|
::Ifc4::IfcAudioVisualApplianceTypeEnum::Value Ifc4::IfcAudioVisualApplianceType::PredefinedType() const { return ::Ifc4::IfcAudioVisualApplianceTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcAudioVisualApplianceType::setPredefinedType(const ::Ifc4::IfcAudioVisualApplianceTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcAudioVisualApplianceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAudioVisualApplianceType::Class() { return *((IfcParse::entity*)IFC4_types[51]); }
|
|
void Ifc4::IfcAudioVisualApplianceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcAudioVisualApplianceTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcAudioVisualApplianceTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcAxis1Placement
|
|
::Ifc4::IfcDirection Ifc4::IfcAxis1Placement::Axis() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcDirection{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcDirection>(); }
|
|
void Ifc4::IfcAxis1Placement::setAxis(const ::Ifc4::IfcDirection& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAxis1Placement::Class() { return *((IfcParse::entity*)IFC4_types[53]); }
|
|
void Ifc4::IfcAxis1Placement::initialize(::Ifc4::IfcCartesianPoint v1_Location, ::Ifc4::IfcDirection v2_Axis) { set_attribute_value(0, (v1_Location));set_attribute_value(1, (v2_Axis)); }
|
|
|
|
// Function implementations for IfcAxis2Placement2D
|
|
::Ifc4::IfcDirection Ifc4::IfcAxis2Placement2D::RefDirection() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcDirection{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcDirection>(); }
|
|
void Ifc4::IfcAxis2Placement2D::setRefDirection(const ::Ifc4::IfcDirection& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAxis2Placement2D::Class() { return *((IfcParse::entity*)IFC4_types[55]); }
|
|
void Ifc4::IfcAxis2Placement2D::initialize(::Ifc4::IfcCartesianPoint v1_Location, ::Ifc4::IfcDirection v2_RefDirection) { set_attribute_value(0, (v1_Location));set_attribute_value(1, (v2_RefDirection)); }
|
|
|
|
// Function implementations for IfcAxis2Placement3D
|
|
::Ifc4::IfcDirection Ifc4::IfcAxis2Placement3D::Axis() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcDirection{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcDirection>(); }
|
|
void Ifc4::IfcAxis2Placement3D::setAxis(const ::Ifc4::IfcDirection& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcDirection Ifc4::IfcAxis2Placement3D::RefDirection() const { if(get_attribute_value(2).isNull()) { return ::Ifc4::IfcDirection{}; } return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcDirection>(); }
|
|
void Ifc4::IfcAxis2Placement3D::setRefDirection(const ::Ifc4::IfcDirection& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcAxis2Placement3D::Class() { return *((IfcParse::entity*)IFC4_types[56]); }
|
|
void Ifc4::IfcAxis2Placement3D::initialize(::Ifc4::IfcCartesianPoint v1_Location, ::Ifc4::IfcDirection v2_Axis, ::Ifc4::IfcDirection v3_RefDirection) { set_attribute_value(0, (v1_Location));set_attribute_value(1, (v2_Axis));set_attribute_value(2, (v3_RefDirection)); }
|
|
|
|
// Function implementations for IfcBSplineCurve
|
|
int Ifc4::IfcBSplineCurve::Degree() const { int v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcBSplineCurve::setDegree(const int& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::vector< ::Ifc4::IfcCartesianPoint > Ifc4::IfcBSplineCurve::ControlPointsList() const { std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcCartesianPoint>(es); }
|
|
void Ifc4::IfcBSplineCurve::setControlPointsList(const std::vector< ::Ifc4::IfcCartesianPoint >& v) { set_attribute_value(1, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcBSplineCurveForm::Value Ifc4::IfcBSplineCurve::CurveForm() const { return ::Ifc4::IfcBSplineCurveForm::FromString(get_attribute_value(2)); }
|
|
void Ifc4::IfcBSplineCurve::setCurveForm(const ::Ifc4::IfcBSplineCurveForm::Value& v) { set_attribute_value(2, EnumerationReference(&::Ifc4::IfcBSplineCurveForm::Class(), (size_t) v));if constexpr (false)unset_attribute_value(2); }
|
|
boost::logic::tribool Ifc4::IfcBSplineCurve::ClosedCurve() const { boost::logic::tribool v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcBSplineCurve::setClosedCurve(const boost::logic::tribool& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
boost::logic::tribool Ifc4::IfcBSplineCurve::SelfIntersect() const { boost::logic::tribool v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcBSplineCurve::setSelfIntersect(const boost::logic::tribool& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBSplineCurve::Class() { return *((IfcParse::entity*)IFC4_types[85]); }
|
|
void Ifc4::IfcBSplineCurve::initialize(int v1_Degree, std::vector< ::Ifc4::IfcCartesianPoint > v2_ControlPointsList, ::Ifc4::IfcBSplineCurveForm::Value v3_CurveForm, boost::logic::tribool v4_ClosedCurve, boost::logic::tribool v5_SelfIntersect) { set_attribute_value(0, (v1_Degree));set_attribute_value(1, cast_vector<express::Base>(v2_ControlPointsList));set_attribute_value(2, (EnumerationReference(&::Ifc4::IfcBSplineCurveForm::Class(),(size_t)v3_CurveForm)));set_attribute_value(3, (v4_ClosedCurve));set_attribute_value(4, (v5_SelfIntersect)); }
|
|
|
|
// Function implementations for IfcBSplineCurveWithKnots
|
|
std::vector< int > /*[2:?]*/ Ifc4::IfcBSplineCurveWithKnots::KnotMultiplicities() const { std::vector< int > /*[2:?]*/ v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcBSplineCurveWithKnots::setKnotMultiplicities(const std::vector< int > /*[2:?]*/& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
std::vector< double > /*[2:?]*/ Ifc4::IfcBSplineCurveWithKnots::Knots() const { std::vector< double > /*[2:?]*/ v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcBSplineCurveWithKnots::setKnots(const std::vector< double > /*[2:?]*/& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
::Ifc4::IfcKnotType::Value Ifc4::IfcBSplineCurveWithKnots::KnotSpec() const { return ::Ifc4::IfcKnotType::FromString(get_attribute_value(7)); }
|
|
void Ifc4::IfcBSplineCurveWithKnots::setKnotSpec(const ::Ifc4::IfcKnotType::Value& v) { set_attribute_value(7, EnumerationReference(&::Ifc4::IfcKnotType::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBSplineCurveWithKnots::Class() { return *((IfcParse::entity*)IFC4_types[87]); }
|
|
void Ifc4::IfcBSplineCurveWithKnots::initialize(int v1_Degree, std::vector< ::Ifc4::IfcCartesianPoint > v2_ControlPointsList, ::Ifc4::IfcBSplineCurveForm::Value v3_CurveForm, boost::logic::tribool v4_ClosedCurve, boost::logic::tribool v5_SelfIntersect, std::vector< int > /*[2:?]*/ v6_KnotMultiplicities, std::vector< double > /*[2:?]*/ v7_Knots, ::Ifc4::IfcKnotType::Value v8_KnotSpec) { set_attribute_value(0, (v1_Degree));set_attribute_value(1, cast_vector<express::Base>(v2_ControlPointsList));set_attribute_value(2, (EnumerationReference(&::Ifc4::IfcBSplineCurveForm::Class(),(size_t)v3_CurveForm)));set_attribute_value(3, (v4_ClosedCurve));set_attribute_value(4, (v5_SelfIntersect));set_attribute_value(5, (v6_KnotMultiplicities));set_attribute_value(6, (v7_Knots));set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcKnotType::Class(),(size_t)v8_KnotSpec))); }
|
|
|
|
// Function implementations for IfcBSplineSurface
|
|
int Ifc4::IfcBSplineSurface::UDegree() const { int v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcBSplineSurface::setUDegree(const int& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
int Ifc4::IfcBSplineSurface::VDegree() const { int v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcBSplineSurface::setVDegree(const int& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
std::vector< std::vector< ::Ifc4::IfcCartesianPoint > > Ifc4::IfcBSplineSurface::ControlPointsList() const { std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcCartesianPoint>(es); }
|
|
void Ifc4::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcBSplineSurfaceForm::Value Ifc4::IfcBSplineSurface::SurfaceForm() const { return ::Ifc4::IfcBSplineSurfaceForm::FromString(get_attribute_value(3)); }
|
|
void Ifc4::IfcBSplineSurface::setSurfaceForm(const ::Ifc4::IfcBSplineSurfaceForm::Value& v) { set_attribute_value(3, EnumerationReference(&::Ifc4::IfcBSplineSurfaceForm::Class(), (size_t) v));if constexpr (false)unset_attribute_value(3); }
|
|
boost::logic::tribool Ifc4::IfcBSplineSurface::UClosed() const { boost::logic::tribool v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcBSplineSurface::setUClosed(const boost::logic::tribool& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
boost::logic::tribool Ifc4::IfcBSplineSurface::VClosed() const { boost::logic::tribool v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcBSplineSurface::setVClosed(const boost::logic::tribool& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
boost::logic::tribool Ifc4::IfcBSplineSurface::SelfIntersect() const { boost::logic::tribool v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcBSplineSurface::setSelfIntersect(const boost::logic::tribool& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBSplineSurface::Class() { return *((IfcParse::entity*)IFC4_types[88]); }
|
|
void Ifc4::IfcBSplineSurface::initialize(int v1_UDegree, int v2_VDegree, std::vector< std::vector< ::Ifc4::IfcCartesianPoint > > v3_ControlPointsList, ::Ifc4::IfcBSplineSurfaceForm::Value v4_SurfaceForm, boost::logic::tribool v5_UClosed, boost::logic::tribool v6_VClosed, boost::logic::tribool v7_SelfIntersect) { set_attribute_value(0, (v1_UDegree));set_attribute_value(1, (v2_VDegree));set_attribute_value(2, cast_vector<express::Base>(v3_ControlPointsList));set_attribute_value(3, (EnumerationReference(&::Ifc4::IfcBSplineSurfaceForm::Class(),(size_t)v4_SurfaceForm)));set_attribute_value(4, (v5_UClosed));set_attribute_value(5, (v6_VClosed));set_attribute_value(6, (v7_SelfIntersect)); }
|
|
|
|
// Function implementations for IfcBSplineSurfaceWithKnots
|
|
std::vector< int > /*[2:?]*/ Ifc4::IfcBSplineSurfaceWithKnots::UMultiplicities() const { std::vector< int > /*[2:?]*/ v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcBSplineSurfaceWithKnots::setUMultiplicities(const std::vector< int > /*[2:?]*/& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
std::vector< int > /*[2:?]*/ Ifc4::IfcBSplineSurfaceWithKnots::VMultiplicities() const { std::vector< int > /*[2:?]*/ v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcBSplineSurfaceWithKnots::setVMultiplicities(const std::vector< int > /*[2:?]*/& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
std::vector< double > /*[2:?]*/ Ifc4::IfcBSplineSurfaceWithKnots::UKnots() const { std::vector< double > /*[2:?]*/ v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcBSplineSurfaceWithKnots::setUKnots(const std::vector< double > /*[2:?]*/& v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }
|
|
std::vector< double > /*[2:?]*/ Ifc4::IfcBSplineSurfaceWithKnots::VKnots() const { std::vector< double > /*[2:?]*/ v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcBSplineSurfaceWithKnots::setVKnots(const std::vector< double > /*[2:?]*/& v) { set_attribute_value(10, v);if constexpr (false)unset_attribute_value(10); }
|
|
::Ifc4::IfcKnotType::Value Ifc4::IfcBSplineSurfaceWithKnots::KnotSpec() const { return ::Ifc4::IfcKnotType::FromString(get_attribute_value(11)); }
|
|
void Ifc4::IfcBSplineSurfaceWithKnots::setKnotSpec(const ::Ifc4::IfcKnotType::Value& v) { set_attribute_value(11, EnumerationReference(&::Ifc4::IfcKnotType::Class(), (size_t) v));if constexpr (false)unset_attribute_value(11); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBSplineSurfaceWithKnots::Class() { return *((IfcParse::entity*)IFC4_types[90]); }
|
|
void Ifc4::IfcBSplineSurfaceWithKnots::initialize(int v1_UDegree, int v2_VDegree, std::vector< std::vector< ::Ifc4::IfcCartesianPoint > > v3_ControlPointsList, ::Ifc4::IfcBSplineSurfaceForm::Value v4_SurfaceForm, boost::logic::tribool v5_UClosed, boost::logic::tribool v6_VClosed, boost::logic::tribool v7_SelfIntersect, std::vector< int > /*[2:?]*/ v8_UMultiplicities, std::vector< int > /*[2:?]*/ v9_VMultiplicities, std::vector< double > /*[2:?]*/ v10_UKnots, std::vector< double > /*[2:?]*/ v11_VKnots, ::Ifc4::IfcKnotType::Value v12_KnotSpec) { set_attribute_value(0, (v1_UDegree));set_attribute_value(1, (v2_VDegree));set_attribute_value(2, cast_vector<express::Base>(v3_ControlPointsList));set_attribute_value(3, (EnumerationReference(&::Ifc4::IfcBSplineSurfaceForm::Class(),(size_t)v4_SurfaceForm)));set_attribute_value(4, (v5_UClosed));set_attribute_value(5, (v6_VClosed));set_attribute_value(6, (v7_SelfIntersect));set_attribute_value(7, (v8_UMultiplicities));set_attribute_value(8, (v9_VMultiplicities));set_attribute_value(9, (v10_UKnots));set_attribute_value(10, (v11_VKnots));set_attribute_value(11, (EnumerationReference(&::Ifc4::IfcKnotType::Class(),(size_t)v12_KnotSpec))); }
|
|
|
|
// Function implementations for IfcBeam
|
|
std::optional< ::Ifc4::IfcBeamTypeEnum::Value > Ifc4::IfcBeam::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcBeamTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcBeam::setPredefinedType(const std::optional< ::Ifc4::IfcBeamTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcBeamTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBeam::Class() { return *((IfcParse::entity*)IFC4_types[57]); }
|
|
void Ifc4::IfcBeam::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcBeamTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcBeamTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcBeamStandardCase
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBeamStandardCase::Class() { return *((IfcParse::entity*)IFC4_types[58]); }
|
|
void Ifc4::IfcBeamStandardCase::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcBeamTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcBeamTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcBeamType
|
|
::Ifc4::IfcBeamTypeEnum::Value Ifc4::IfcBeamType::PredefinedType() const { return ::Ifc4::IfcBeamTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcBeamType::setPredefinedType(const ::Ifc4::IfcBeamTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcBeamTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBeamType::Class() { return *((IfcParse::entity*)IFC4_types[59]); }
|
|
void Ifc4::IfcBeamType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcBeamTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcBeamTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcBlobTexture
|
|
std::string Ifc4::IfcBlobTexture::RasterFormat() const { std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcBlobTexture::setRasterFormat(const std::string& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
boost::dynamic_bitset<> Ifc4::IfcBlobTexture::RasterCode() const { boost::dynamic_bitset<> v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcBlobTexture::setRasterCode(const boost::dynamic_bitset<>& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBlobTexture::Class() { return *((IfcParse::entity*)IFC4_types[64]); }
|
|
void Ifc4::IfcBlobTexture::initialize(bool v1_RepeatS, bool v2_RepeatT, std::optional< std::string > v3_Mode, ::Ifc4::IfcCartesianTransformationOperator2D v4_TextureTransform, std::optional< std::vector< std::string > /*[1:?]*/ > v5_Parameter, std::string v6_RasterFormat, boost::dynamic_bitset<> v7_RasterCode) { set_attribute_value(0, (v1_RepeatS));set_attribute_value(1, (v2_RepeatT)); if (v3_Mode) {set_attribute_value(2, (*v3_Mode)); }set_attribute_value(3, (v4_TextureTransform)); if (v5_Parameter) {set_attribute_value(4, (*v5_Parameter)); }set_attribute_value(5, (v6_RasterFormat));set_attribute_value(6, (v7_RasterCode)); }
|
|
|
|
// Function implementations for IfcBlock
|
|
double Ifc4::IfcBlock::XLength() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcBlock::setXLength(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
double Ifc4::IfcBlock::YLength() const { double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcBlock::setYLength(const double& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
double Ifc4::IfcBlock::ZLength() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcBlock::setZLength(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBlock::Class() { return *((IfcParse::entity*)IFC4_types[65]); }
|
|
void Ifc4::IfcBlock::initialize(::Ifc4::IfcAxis2Placement3D v1_Position, double v2_XLength, double v3_YLength, double v4_ZLength) { set_attribute_value(0, (v1_Position));set_attribute_value(1, (v2_XLength));set_attribute_value(2, (v3_YLength));set_attribute_value(3, (v4_ZLength)); }
|
|
|
|
// Function implementations for IfcBoiler
|
|
std::optional< ::Ifc4::IfcBoilerTypeEnum::Value > Ifc4::IfcBoiler::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcBoilerTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcBoiler::setPredefinedType(const std::optional< ::Ifc4::IfcBoilerTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcBoilerTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBoiler::Class() { return *((IfcParse::entity*)IFC4_types[66]); }
|
|
void Ifc4::IfcBoiler::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcBoilerTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcBoilerTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcBoilerType
|
|
::Ifc4::IfcBoilerTypeEnum::Value Ifc4::IfcBoilerType::PredefinedType() const { return ::Ifc4::IfcBoilerTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcBoilerType::setPredefinedType(const ::Ifc4::IfcBoilerTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcBoilerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBoilerType::Class() { return *((IfcParse::entity*)IFC4_types[67]); }
|
|
void Ifc4::IfcBoilerType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcBoilerTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcBoilerTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcBooleanClippingResult
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBooleanClippingResult::Class() { return *((IfcParse::entity*)IFC4_types[70]); }
|
|
void Ifc4::IfcBooleanClippingResult::initialize(::Ifc4::IfcBooleanOperator::Value v1_Operator, ::Ifc4::IfcBooleanOperand v2_FirstOperand, ::Ifc4::IfcBooleanOperand v3_SecondOperand) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcBooleanOperator::Class(),(size_t)v1_Operator)));set_attribute_value(1, (v2_FirstOperand));set_attribute_value(2, (v3_SecondOperand)); }
|
|
|
|
// Function implementations for IfcBooleanResult
|
|
::Ifc4::IfcBooleanOperator::Value Ifc4::IfcBooleanResult::Operator() const { return ::Ifc4::IfcBooleanOperator::FromString(get_attribute_value(0)); }
|
|
void Ifc4::IfcBooleanResult::setOperator(const ::Ifc4::IfcBooleanOperator::Value& v) { set_attribute_value(0, EnumerationReference(&::Ifc4::IfcBooleanOperator::Class(), (size_t) v));if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcBooleanOperand Ifc4::IfcBooleanResult::FirstOperand() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcBooleanOperand>(); }
|
|
void Ifc4::IfcBooleanResult::setFirstOperand(const ::Ifc4::IfcBooleanOperand& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcBooleanOperand Ifc4::IfcBooleanResult::SecondOperand() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcBooleanOperand>(); }
|
|
void Ifc4::IfcBooleanResult::setSecondOperand(const ::Ifc4::IfcBooleanOperand& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBooleanResult::Class() { return *((IfcParse::entity*)IFC4_types[73]); }
|
|
void Ifc4::IfcBooleanResult::initialize(::Ifc4::IfcBooleanOperator::Value v1_Operator, ::Ifc4::IfcBooleanOperand v2_FirstOperand, ::Ifc4::IfcBooleanOperand v3_SecondOperand) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcBooleanOperator::Class(),(size_t)v1_Operator)));set_attribute_value(1, (v2_FirstOperand));set_attribute_value(2, (v3_SecondOperand)); }
|
|
|
|
// Function implementations for IfcBoundaryCondition
|
|
std::optional< std::string > Ifc4::IfcBoundaryCondition::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcBoundaryCondition::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBoundaryCondition::Class() { return *((IfcParse::entity*)IFC4_types[74]); }
|
|
void Ifc4::IfcBoundaryCondition::initialize(std::optional< std::string > v1_Name) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } }
|
|
|
|
// Function implementations for IfcBoundaryCurve
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBoundaryCurve::Class() { return *((IfcParse::entity*)IFC4_types[75]); }
|
|
void Ifc4::IfcBoundaryCurve::initialize(std::vector< ::Ifc4::IfcCompositeCurveSegment > v1_Segments, boost::logic::tribool v2_SelfIntersect) { set_attribute_value(0, cast_vector<express::Base>(v1_Segments));set_attribute_value(1, (v2_SelfIntersect)); }
|
|
|
|
// Function implementations for IfcBoundaryEdgeCondition
|
|
::Ifc4::IfcModulusOfTranslationalSubgradeReactionSelect Ifc4::IfcBoundaryEdgeCondition::TranslationalStiffnessByLengthX() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcModulusOfTranslationalSubgradeReactionSelect{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcModulusOfTranslationalSubgradeReactionSelect>(); }
|
|
void Ifc4::IfcBoundaryEdgeCondition::setTranslationalStiffnessByLengthX(const ::Ifc4::IfcModulusOfTranslationalSubgradeReactionSelect& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcModulusOfTranslationalSubgradeReactionSelect Ifc4::IfcBoundaryEdgeCondition::TranslationalStiffnessByLengthY() const { if(get_attribute_value(2).isNull()) { return ::Ifc4::IfcModulusOfTranslationalSubgradeReactionSelect{}; } return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcModulusOfTranslationalSubgradeReactionSelect>(); }
|
|
void Ifc4::IfcBoundaryEdgeCondition::setTranslationalStiffnessByLengthY(const ::Ifc4::IfcModulusOfTranslationalSubgradeReactionSelect& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcModulusOfTranslationalSubgradeReactionSelect Ifc4::IfcBoundaryEdgeCondition::TranslationalStiffnessByLengthZ() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcModulusOfTranslationalSubgradeReactionSelect{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcModulusOfTranslationalSubgradeReactionSelect>(); }
|
|
void Ifc4::IfcBoundaryEdgeCondition::setTranslationalStiffnessByLengthZ(const ::Ifc4::IfcModulusOfTranslationalSubgradeReactionSelect& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
::Ifc4::IfcModulusOfRotationalSubgradeReactionSelect Ifc4::IfcBoundaryEdgeCondition::RotationalStiffnessByLengthX() const { if(get_attribute_value(4).isNull()) { return ::Ifc4::IfcModulusOfRotationalSubgradeReactionSelect{}; } return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcModulusOfRotationalSubgradeReactionSelect>(); }
|
|
void Ifc4::IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthX(const ::Ifc4::IfcModulusOfRotationalSubgradeReactionSelect& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcModulusOfRotationalSubgradeReactionSelect Ifc4::IfcBoundaryEdgeCondition::RotationalStiffnessByLengthY() const { if(get_attribute_value(5).isNull()) { return ::Ifc4::IfcModulusOfRotationalSubgradeReactionSelect{}; } return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcModulusOfRotationalSubgradeReactionSelect>(); }
|
|
void Ifc4::IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthY(const ::Ifc4::IfcModulusOfRotationalSubgradeReactionSelect& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
::Ifc4::IfcModulusOfRotationalSubgradeReactionSelect Ifc4::IfcBoundaryEdgeCondition::RotationalStiffnessByLengthZ() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcModulusOfRotationalSubgradeReactionSelect{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcModulusOfRotationalSubgradeReactionSelect>(); }
|
|
void Ifc4::IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthZ(const ::Ifc4::IfcModulusOfRotationalSubgradeReactionSelect& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBoundaryEdgeCondition::Class() { return *((IfcParse::entity*)IFC4_types[76]); }
|
|
void Ifc4::IfcBoundaryEdgeCondition::initialize(std::optional< std::string > v1_Name, ::Ifc4::IfcModulusOfTranslationalSubgradeReactionSelect v2_TranslationalStiffnessByLengthX, ::Ifc4::IfcModulusOfTranslationalSubgradeReactionSelect v3_TranslationalStiffnessByLengthY, ::Ifc4::IfcModulusOfTranslationalSubgradeReactionSelect v4_TranslationalStiffnessByLengthZ, ::Ifc4::IfcModulusOfRotationalSubgradeReactionSelect v5_RotationalStiffnessByLengthX, ::Ifc4::IfcModulusOfRotationalSubgradeReactionSelect v6_RotationalStiffnessByLengthY, ::Ifc4::IfcModulusOfRotationalSubgradeReactionSelect v7_RotationalStiffnessByLengthZ) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (v2_TranslationalStiffnessByLengthX));set_attribute_value(2, (v3_TranslationalStiffnessByLengthY));set_attribute_value(3, (v4_TranslationalStiffnessByLengthZ));set_attribute_value(4, (v5_RotationalStiffnessByLengthX));set_attribute_value(5, (v6_RotationalStiffnessByLengthY));set_attribute_value(6, (v7_RotationalStiffnessByLengthZ)); }
|
|
|
|
// Function implementations for IfcBoundaryFaceCondition
|
|
::Ifc4::IfcModulusOfSubgradeReactionSelect Ifc4::IfcBoundaryFaceCondition::TranslationalStiffnessByAreaX() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcModulusOfSubgradeReactionSelect{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcModulusOfSubgradeReactionSelect>(); }
|
|
void Ifc4::IfcBoundaryFaceCondition::setTranslationalStiffnessByAreaX(const ::Ifc4::IfcModulusOfSubgradeReactionSelect& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcModulusOfSubgradeReactionSelect Ifc4::IfcBoundaryFaceCondition::TranslationalStiffnessByAreaY() const { if(get_attribute_value(2).isNull()) { return ::Ifc4::IfcModulusOfSubgradeReactionSelect{}; } return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcModulusOfSubgradeReactionSelect>(); }
|
|
void Ifc4::IfcBoundaryFaceCondition::setTranslationalStiffnessByAreaY(const ::Ifc4::IfcModulusOfSubgradeReactionSelect& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcModulusOfSubgradeReactionSelect Ifc4::IfcBoundaryFaceCondition::TranslationalStiffnessByAreaZ() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcModulusOfSubgradeReactionSelect{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcModulusOfSubgradeReactionSelect>(); }
|
|
void Ifc4::IfcBoundaryFaceCondition::setTranslationalStiffnessByAreaZ(const ::Ifc4::IfcModulusOfSubgradeReactionSelect& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBoundaryFaceCondition::Class() { return *((IfcParse::entity*)IFC4_types[77]); }
|
|
void Ifc4::IfcBoundaryFaceCondition::initialize(std::optional< std::string > v1_Name, ::Ifc4::IfcModulusOfSubgradeReactionSelect v2_TranslationalStiffnessByAreaX, ::Ifc4::IfcModulusOfSubgradeReactionSelect v3_TranslationalStiffnessByAreaY, ::Ifc4::IfcModulusOfSubgradeReactionSelect v4_TranslationalStiffnessByAreaZ) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (v2_TranslationalStiffnessByAreaX));set_attribute_value(2, (v3_TranslationalStiffnessByAreaY));set_attribute_value(3, (v4_TranslationalStiffnessByAreaZ)); }
|
|
|
|
// Function implementations for IfcBoundaryNodeCondition
|
|
::Ifc4::IfcTranslationalStiffnessSelect Ifc4::IfcBoundaryNodeCondition::TranslationalStiffnessX() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcTranslationalStiffnessSelect{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcTranslationalStiffnessSelect>(); }
|
|
void Ifc4::IfcBoundaryNodeCondition::setTranslationalStiffnessX(const ::Ifc4::IfcTranslationalStiffnessSelect& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcTranslationalStiffnessSelect Ifc4::IfcBoundaryNodeCondition::TranslationalStiffnessY() const { if(get_attribute_value(2).isNull()) { return ::Ifc4::IfcTranslationalStiffnessSelect{}; } return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcTranslationalStiffnessSelect>(); }
|
|
void Ifc4::IfcBoundaryNodeCondition::setTranslationalStiffnessY(const ::Ifc4::IfcTranslationalStiffnessSelect& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcTranslationalStiffnessSelect Ifc4::IfcBoundaryNodeCondition::TranslationalStiffnessZ() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcTranslationalStiffnessSelect{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcTranslationalStiffnessSelect>(); }
|
|
void Ifc4::IfcBoundaryNodeCondition::setTranslationalStiffnessZ(const ::Ifc4::IfcTranslationalStiffnessSelect& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
::Ifc4::IfcRotationalStiffnessSelect Ifc4::IfcBoundaryNodeCondition::RotationalStiffnessX() const { if(get_attribute_value(4).isNull()) { return ::Ifc4::IfcRotationalStiffnessSelect{}; } return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcRotationalStiffnessSelect>(); }
|
|
void Ifc4::IfcBoundaryNodeCondition::setRotationalStiffnessX(const ::Ifc4::IfcRotationalStiffnessSelect& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcRotationalStiffnessSelect Ifc4::IfcBoundaryNodeCondition::RotationalStiffnessY() const { if(get_attribute_value(5).isNull()) { return ::Ifc4::IfcRotationalStiffnessSelect{}; } return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcRotationalStiffnessSelect>(); }
|
|
void Ifc4::IfcBoundaryNodeCondition::setRotationalStiffnessY(const ::Ifc4::IfcRotationalStiffnessSelect& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
::Ifc4::IfcRotationalStiffnessSelect Ifc4::IfcBoundaryNodeCondition::RotationalStiffnessZ() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcRotationalStiffnessSelect{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcRotationalStiffnessSelect>(); }
|
|
void Ifc4::IfcBoundaryNodeCondition::setRotationalStiffnessZ(const ::Ifc4::IfcRotationalStiffnessSelect& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBoundaryNodeCondition::Class() { return *((IfcParse::entity*)IFC4_types[78]); }
|
|
void Ifc4::IfcBoundaryNodeCondition::initialize(std::optional< std::string > v1_Name, ::Ifc4::IfcTranslationalStiffnessSelect v2_TranslationalStiffnessX, ::Ifc4::IfcTranslationalStiffnessSelect v3_TranslationalStiffnessY, ::Ifc4::IfcTranslationalStiffnessSelect v4_TranslationalStiffnessZ, ::Ifc4::IfcRotationalStiffnessSelect v5_RotationalStiffnessX, ::Ifc4::IfcRotationalStiffnessSelect v6_RotationalStiffnessY, ::Ifc4::IfcRotationalStiffnessSelect v7_RotationalStiffnessZ) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (v2_TranslationalStiffnessX));set_attribute_value(2, (v3_TranslationalStiffnessY));set_attribute_value(3, (v4_TranslationalStiffnessZ));set_attribute_value(4, (v5_RotationalStiffnessX));set_attribute_value(5, (v6_RotationalStiffnessY));set_attribute_value(6, (v7_RotationalStiffnessZ)); }
|
|
|
|
// Function implementations for IfcBoundaryNodeConditionWarping
|
|
::Ifc4::IfcWarpingStiffnessSelect Ifc4::IfcBoundaryNodeConditionWarping::WarpingStiffness() const { if(get_attribute_value(7).isNull()) { return ::Ifc4::IfcWarpingStiffnessSelect{}; } return ((express::Base)(get_attribute_value(7))).as<::Ifc4::IfcWarpingStiffnessSelect>(); }
|
|
void Ifc4::IfcBoundaryNodeConditionWarping::setWarpingStiffness(const ::Ifc4::IfcWarpingStiffnessSelect& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBoundaryNodeConditionWarping::Class() { return *((IfcParse::entity*)IFC4_types[79]); }
|
|
void Ifc4::IfcBoundaryNodeConditionWarping::initialize(std::optional< std::string > v1_Name, ::Ifc4::IfcTranslationalStiffnessSelect v2_TranslationalStiffnessX, ::Ifc4::IfcTranslationalStiffnessSelect v3_TranslationalStiffnessY, ::Ifc4::IfcTranslationalStiffnessSelect v4_TranslationalStiffnessZ, ::Ifc4::IfcRotationalStiffnessSelect v5_RotationalStiffnessX, ::Ifc4::IfcRotationalStiffnessSelect v6_RotationalStiffnessY, ::Ifc4::IfcRotationalStiffnessSelect v7_RotationalStiffnessZ, ::Ifc4::IfcWarpingStiffnessSelect v8_WarpingStiffness) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (v2_TranslationalStiffnessX));set_attribute_value(2, (v3_TranslationalStiffnessY));set_attribute_value(3, (v4_TranslationalStiffnessZ));set_attribute_value(4, (v5_RotationalStiffnessX));set_attribute_value(5, (v6_RotationalStiffnessY));set_attribute_value(6, (v7_RotationalStiffnessZ));set_attribute_value(7, (v8_WarpingStiffness)); }
|
|
|
|
// Function implementations for IfcBoundedCurve
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBoundedCurve::Class() { return *((IfcParse::entity*)IFC4_types[80]); }
|
|
void Ifc4::IfcBoundedCurve::initialize() { }
|
|
|
|
// Function implementations for IfcBoundedSurface
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBoundedSurface::Class() { return *((IfcParse::entity*)IFC4_types[81]); }
|
|
void Ifc4::IfcBoundedSurface::initialize() { }
|
|
|
|
// Function implementations for IfcBoundingBox
|
|
::Ifc4::IfcCartesianPoint Ifc4::IfcBoundingBox::Corner() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcCartesianPoint>(); }
|
|
void Ifc4::IfcBoundingBox::setCorner(const ::Ifc4::IfcCartesianPoint& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
double Ifc4::IfcBoundingBox::XDim() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcBoundingBox::setXDim(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
double Ifc4::IfcBoundingBox::YDim() const { double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcBoundingBox::setYDim(const double& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
double Ifc4::IfcBoundingBox::ZDim() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcBoundingBox::setZDim(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBoundingBox::Class() { return *((IfcParse::entity*)IFC4_types[82]); }
|
|
void Ifc4::IfcBoundingBox::initialize(::Ifc4::IfcCartesianPoint v1_Corner, double v2_XDim, double v3_YDim, double v4_ZDim) { set_attribute_value(0, (v1_Corner));set_attribute_value(1, (v2_XDim));set_attribute_value(2, (v3_YDim));set_attribute_value(3, (v4_ZDim)); }
|
|
|
|
// Function implementations for IfcBoxedHalfSpace
|
|
::Ifc4::IfcBoundingBox Ifc4::IfcBoxedHalfSpace::Enclosure() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcBoundingBox>(); }
|
|
void Ifc4::IfcBoxedHalfSpace::setEnclosure(const ::Ifc4::IfcBoundingBox& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBoxedHalfSpace::Class() { return *((IfcParse::entity*)IFC4_types[84]); }
|
|
void Ifc4::IfcBoxedHalfSpace::initialize(::Ifc4::IfcSurface v1_BaseSurface, bool v2_AgreementFlag, ::Ifc4::IfcBoundingBox v3_Enclosure) { set_attribute_value(0, (v1_BaseSurface));set_attribute_value(1, (v2_AgreementFlag));set_attribute_value(2, (v3_Enclosure)); }
|
|
|
|
// Function implementations for IfcBuilding
|
|
std::optional< double > Ifc4::IfcBuilding::ElevationOfRefHeight() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } double v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcBuilding::setElevationOfRefHeight(const std::optional< double >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
std::optional< double > Ifc4::IfcBuilding::ElevationOfTerrain() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } double v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcBuilding::setElevationOfTerrain(const std::optional< double >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
::Ifc4::IfcPostalAddress Ifc4::IfcBuilding::BuildingAddress() const { if(get_attribute_value(11).isNull()) { return ::Ifc4::IfcPostalAddress{}; } return ((express::Base)(get_attribute_value(11))).as<::Ifc4::IfcPostalAddress>(); }
|
|
void Ifc4::IfcBuilding::setBuildingAddress(const ::Ifc4::IfcPostalAddress& v) { set_attribute_value(11, v);if constexpr (false)unset_attribute_value(11); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBuilding::Class() { return *((IfcParse::entity*)IFC4_types[91]); }
|
|
void Ifc4::IfcBuilding::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_LongName, std::optional< ::Ifc4::IfcElementCompositionEnum::Value > v9_CompositionType, std::optional< double > v10_ElevationOfRefHeight, std::optional< double > v11_ElevationOfTerrain, ::Ifc4::IfcPostalAddress v12_BuildingAddress) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_LongName) {set_attribute_value(7, (*v8_LongName)); } if (v9_CompositionType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::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)); }
|
|
|
|
// Function implementations for IfcBuildingElement
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBuildingElement::Class() { return *((IfcParse::entity*)IFC4_types[92]); }
|
|
void Ifc4::IfcBuildingElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcBuildingElementPart
|
|
std::optional< ::Ifc4::IfcBuildingElementPartTypeEnum::Value > Ifc4::IfcBuildingElementPart::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcBuildingElementPartTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcBuildingElementPart::setPredefinedType(const std::optional< ::Ifc4::IfcBuildingElementPartTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcBuildingElementPartTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBuildingElementPart::Class() { return *((IfcParse::entity*)IFC4_types[93]); }
|
|
void Ifc4::IfcBuildingElementPart::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcBuildingElementPartTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcBuildingElementPartTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcBuildingElementPartType
|
|
::Ifc4::IfcBuildingElementPartTypeEnum::Value Ifc4::IfcBuildingElementPartType::PredefinedType() const { return ::Ifc4::IfcBuildingElementPartTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcBuildingElementPartType::setPredefinedType(const ::Ifc4::IfcBuildingElementPartTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcBuildingElementPartTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBuildingElementPartType::Class() { return *((IfcParse::entity*)IFC4_types[94]); }
|
|
void Ifc4::IfcBuildingElementPartType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcBuildingElementPartTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcBuildingElementPartTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcBuildingElementProxy
|
|
std::optional< ::Ifc4::IfcBuildingElementProxyTypeEnum::Value > Ifc4::IfcBuildingElementProxy::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcBuildingElementProxyTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcBuildingElementProxy::setPredefinedType(const std::optional< ::Ifc4::IfcBuildingElementProxyTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcBuildingElementProxyTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBuildingElementProxy::Class() { return *((IfcParse::entity*)IFC4_types[96]); }
|
|
void Ifc4::IfcBuildingElementProxy::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcBuildingElementProxyTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcBuildingElementProxyTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcBuildingElementProxyType
|
|
::Ifc4::IfcBuildingElementProxyTypeEnum::Value Ifc4::IfcBuildingElementProxyType::PredefinedType() const { return ::Ifc4::IfcBuildingElementProxyTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcBuildingElementProxyType::setPredefinedType(const ::Ifc4::IfcBuildingElementProxyTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcBuildingElementProxyTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBuildingElementProxyType::Class() { return *((IfcParse::entity*)IFC4_types[97]); }
|
|
void Ifc4::IfcBuildingElementProxyType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcBuildingElementProxyTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcBuildingElementProxyTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcBuildingElementType
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBuildingElementType::Class() { return *((IfcParse::entity*)IFC4_types[99]); }
|
|
void Ifc4::IfcBuildingElementType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcBuildingStorey
|
|
std::optional< double > Ifc4::IfcBuildingStorey::Elevation() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } double v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcBuildingStorey::setElevation(const std::optional< double >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBuildingStorey::Class() { return *((IfcParse::entity*)IFC4_types[100]); }
|
|
void Ifc4::IfcBuildingStorey::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_LongName, std::optional< ::Ifc4::IfcElementCompositionEnum::Value > v9_CompositionType, std::optional< double > v10_Elevation) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_LongName) {set_attribute_value(7, (*v8_LongName)); } if (v9_CompositionType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcElementCompositionEnum::Class(),(size_t)*v9_CompositionType))); } if (v10_Elevation) {set_attribute_value(9, (*v10_Elevation)); } }
|
|
|
|
// Function implementations for IfcBuildingSystem
|
|
std::optional< ::Ifc4::IfcBuildingSystemTypeEnum::Value > Ifc4::IfcBuildingSystem::PredefinedType() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } return ::Ifc4::IfcBuildingSystemTypeEnum::FromString(get_attribute_value(5)); }
|
|
void Ifc4::IfcBuildingSystem::setPredefinedType(const std::optional< ::Ifc4::IfcBuildingSystemTypeEnum::Value >& v) { if (v) {set_attribute_value(5, EnumerationReference(&::Ifc4::IfcBuildingSystemTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(5);} }
|
|
std::optional< std::string > Ifc4::IfcBuildingSystem::LongName() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcBuildingSystem::setLongName(const std::optional< std::string >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBuildingSystem::Class() { return *((IfcParse::entity*)IFC4_types[101]); }
|
|
void Ifc4::IfcBuildingSystem::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< ::Ifc4::IfcBuildingSystemTypeEnum::Value > v6_PredefinedType, std::optional< std::string > v7_LongName) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_PredefinedType) {set_attribute_value(5, (EnumerationReference(&::Ifc4::IfcBuildingSystemTypeEnum::Class(),(size_t)*v6_PredefinedType))); } if (v7_LongName) {set_attribute_value(6, (*v7_LongName)); } }
|
|
|
|
// Function implementations for IfcBurner
|
|
std::optional< ::Ifc4::IfcBurnerTypeEnum::Value > Ifc4::IfcBurner::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcBurnerTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcBurner::setPredefinedType(const std::optional< ::Ifc4::IfcBurnerTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcBurnerTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBurner::Class() { return *((IfcParse::entity*)IFC4_types[103]); }
|
|
void Ifc4::IfcBurner::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcBurnerTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcBurnerTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcBurnerType
|
|
::Ifc4::IfcBurnerTypeEnum::Value Ifc4::IfcBurnerType::PredefinedType() const { return ::Ifc4::IfcBurnerTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcBurnerType::setPredefinedType(const ::Ifc4::IfcBurnerTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcBurnerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcBurnerType::Class() { return *((IfcParse::entity*)IFC4_types[104]); }
|
|
void Ifc4::IfcBurnerType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcBurnerTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcBurnerTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcCShapeProfileDef
|
|
double Ifc4::IfcCShapeProfileDef::Depth() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcCShapeProfileDef::setDepth(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
double Ifc4::IfcCShapeProfileDef::Width() const { double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcCShapeProfileDef::setWidth(const double& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
double Ifc4::IfcCShapeProfileDef::WallThickness() const { double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcCShapeProfileDef::setWallThickness(const double& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
double Ifc4::IfcCShapeProfileDef::Girth() const { double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcCShapeProfileDef::setGirth(const double& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
std::optional< double > Ifc4::IfcCShapeProfileDef::InternalFilletRadius() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcCShapeProfileDef::setInternalFilletRadius(const std::optional< double >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCShapeProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[231]); }
|
|
void Ifc4::IfcCShapeProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcAxis2Placement2D v3_Position, double v4_Depth, double v5_Width, double v6_WallThickness, double v7_Girth, std::optional< double > v8_InternalFilletRadius) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Position));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)); } }
|
|
|
|
// Function implementations for IfcCableCarrierFitting
|
|
std::optional< ::Ifc4::IfcCableCarrierFittingTypeEnum::Value > Ifc4::IfcCableCarrierFitting::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcCableCarrierFittingTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcCableCarrierFitting::setPredefinedType(const std::optional< ::Ifc4::IfcCableCarrierFittingTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcCableCarrierFittingTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCableCarrierFitting::Class() { return *((IfcParse::entity*)IFC4_types[106]); }
|
|
void Ifc4::IfcCableCarrierFitting::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcCableCarrierFittingTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcCableCarrierFittingTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcCableCarrierFittingType
|
|
::Ifc4::IfcCableCarrierFittingTypeEnum::Value Ifc4::IfcCableCarrierFittingType::PredefinedType() const { return ::Ifc4::IfcCableCarrierFittingTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcCableCarrierFittingType::setPredefinedType(const ::Ifc4::IfcCableCarrierFittingTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcCableCarrierFittingTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCableCarrierFittingType::Class() { return *((IfcParse::entity*)IFC4_types[107]); }
|
|
void Ifc4::IfcCableCarrierFittingType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcCableCarrierFittingTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcCableCarrierFittingTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcCableCarrierSegment
|
|
std::optional< ::Ifc4::IfcCableCarrierSegmentTypeEnum::Value > Ifc4::IfcCableCarrierSegment::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcCableCarrierSegmentTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcCableCarrierSegment::setPredefinedType(const std::optional< ::Ifc4::IfcCableCarrierSegmentTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcCableCarrierSegmentTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCableCarrierSegment::Class() { return *((IfcParse::entity*)IFC4_types[109]); }
|
|
void Ifc4::IfcCableCarrierSegment::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcCableCarrierSegmentTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcCableCarrierSegmentTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcCableCarrierSegmentType
|
|
::Ifc4::IfcCableCarrierSegmentTypeEnum::Value Ifc4::IfcCableCarrierSegmentType::PredefinedType() const { return ::Ifc4::IfcCableCarrierSegmentTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcCableCarrierSegmentType::setPredefinedType(const ::Ifc4::IfcCableCarrierSegmentTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcCableCarrierSegmentTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCableCarrierSegmentType::Class() { return *((IfcParse::entity*)IFC4_types[110]); }
|
|
void Ifc4::IfcCableCarrierSegmentType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcCableCarrierSegmentTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcCableCarrierSegmentTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcCableFitting
|
|
std::optional< ::Ifc4::IfcCableFittingTypeEnum::Value > Ifc4::IfcCableFitting::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcCableFittingTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcCableFitting::setPredefinedType(const std::optional< ::Ifc4::IfcCableFittingTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcCableFittingTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCableFitting::Class() { return *((IfcParse::entity*)IFC4_types[112]); }
|
|
void Ifc4::IfcCableFitting::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcCableFittingTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcCableFittingTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcCableFittingType
|
|
::Ifc4::IfcCableFittingTypeEnum::Value Ifc4::IfcCableFittingType::PredefinedType() const { return ::Ifc4::IfcCableFittingTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcCableFittingType::setPredefinedType(const ::Ifc4::IfcCableFittingTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcCableFittingTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCableFittingType::Class() { return *((IfcParse::entity*)IFC4_types[113]); }
|
|
void Ifc4::IfcCableFittingType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcCableFittingTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcCableFittingTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcCableSegment
|
|
std::optional< ::Ifc4::IfcCableSegmentTypeEnum::Value > Ifc4::IfcCableSegment::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcCableSegmentTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcCableSegment::setPredefinedType(const std::optional< ::Ifc4::IfcCableSegmentTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcCableSegmentTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCableSegment::Class() { return *((IfcParse::entity*)IFC4_types[115]); }
|
|
void Ifc4::IfcCableSegment::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcCableSegmentTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcCableSegmentTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcCableSegmentType
|
|
::Ifc4::IfcCableSegmentTypeEnum::Value Ifc4::IfcCableSegmentType::PredefinedType() const { return ::Ifc4::IfcCableSegmentTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcCableSegmentType::setPredefinedType(const ::Ifc4::IfcCableSegmentTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcCableSegmentTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCableSegmentType::Class() { return *((IfcParse::entity*)IFC4_types[116]); }
|
|
void Ifc4::IfcCableSegmentType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcCableSegmentTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcCableSegmentTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcCartesianPoint
|
|
std::vector< double > /*[1:3]*/ Ifc4::IfcCartesianPoint::Coordinates() const { std::vector< double > /*[1:3]*/ v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcCartesianPoint::setCoordinates(const std::vector< double > /*[1:3]*/& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCartesianPoint::Class() { return *((IfcParse::entity*)IFC4_types[119]); }
|
|
void Ifc4::IfcCartesianPoint::initialize(std::vector< double > /*[1:3]*/ v1_Coordinates) { set_attribute_value(0, (v1_Coordinates)); }
|
|
|
|
// Function implementations for IfcCartesianPointList
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCartesianPointList::Class() { return *((IfcParse::entity*)IFC4_types[120]); }
|
|
void Ifc4::IfcCartesianPointList::initialize() { }
|
|
|
|
// Function implementations for IfcCartesianPointList2D
|
|
std::vector< std::vector< double > > Ifc4::IfcCartesianPointList2D::CoordList() const { std::vector< std::vector< double > > v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcCartesianPointList2D::setCoordList(const std::vector< std::vector< double > >& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCartesianPointList2D::Class() { return *((IfcParse::entity*)IFC4_types[121]); }
|
|
void Ifc4::IfcCartesianPointList2D::initialize(std::vector< std::vector< double > > v1_CoordList) { set_attribute_value(0, (v1_CoordList)); }
|
|
|
|
// Function implementations for IfcCartesianPointList3D
|
|
std::vector< std::vector< double > > Ifc4::IfcCartesianPointList3D::CoordList() const { std::vector< std::vector< double > > v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcCartesianPointList3D::setCoordList(const std::vector< std::vector< double > >& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCartesianPointList3D::Class() { return *((IfcParse::entity*)IFC4_types[122]); }
|
|
void Ifc4::IfcCartesianPointList3D::initialize(std::vector< std::vector< double > > v1_CoordList) { set_attribute_value(0, (v1_CoordList)); }
|
|
|
|
// Function implementations for IfcCartesianTransformationOperator
|
|
::Ifc4::IfcDirection Ifc4::IfcCartesianTransformationOperator::Axis1() const { if(get_attribute_value(0).isNull()) { return ::Ifc4::IfcDirection{}; } return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcDirection>(); }
|
|
void Ifc4::IfcCartesianTransformationOperator::setAxis1(const ::Ifc4::IfcDirection& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcDirection Ifc4::IfcCartesianTransformationOperator::Axis2() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcDirection{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcDirection>(); }
|
|
void Ifc4::IfcCartesianTransformationOperator::setAxis2(const ::Ifc4::IfcDirection& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcCartesianPoint Ifc4::IfcCartesianTransformationOperator::LocalOrigin() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcCartesianPoint>(); }
|
|
void Ifc4::IfcCartesianTransformationOperator::setLocalOrigin(const ::Ifc4::IfcCartesianPoint& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
std::optional< double > Ifc4::IfcCartesianTransformationOperator::Scale() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcCartesianTransformationOperator::setScale(const std::optional< double >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCartesianTransformationOperator::Class() { return *((IfcParse::entity*)IFC4_types[123]); }
|
|
void Ifc4::IfcCartesianTransformationOperator::initialize(::Ifc4::IfcDirection v1_Axis1, ::Ifc4::IfcDirection v2_Axis2, ::Ifc4::IfcCartesianPoint v3_LocalOrigin, std::optional< double > v4_Scale) { set_attribute_value(0, (v1_Axis1));set_attribute_value(1, (v2_Axis2));set_attribute_value(2, (v3_LocalOrigin)); if (v4_Scale) {set_attribute_value(3, (*v4_Scale)); } }
|
|
|
|
// Function implementations for IfcCartesianTransformationOperator2D
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCartesianTransformationOperator2D::Class() { return *((IfcParse::entity*)IFC4_types[124]); }
|
|
void Ifc4::IfcCartesianTransformationOperator2D::initialize(::Ifc4::IfcDirection v1_Axis1, ::Ifc4::IfcDirection v2_Axis2, ::Ifc4::IfcCartesianPoint v3_LocalOrigin, std::optional< double > v4_Scale) { set_attribute_value(0, (v1_Axis1));set_attribute_value(1, (v2_Axis2));set_attribute_value(2, (v3_LocalOrigin)); if (v4_Scale) {set_attribute_value(3, (*v4_Scale)); } }
|
|
|
|
// Function implementations for IfcCartesianTransformationOperator2DnonUniform
|
|
std::optional< double > Ifc4::IfcCartesianTransformationOperator2DnonUniform::Scale2() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcCartesianTransformationOperator2DnonUniform::setScale2(const std::optional< double >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCartesianTransformationOperator2DnonUniform::Class() { return *((IfcParse::entity*)IFC4_types[125]); }
|
|
void Ifc4::IfcCartesianTransformationOperator2DnonUniform::initialize(::Ifc4::IfcDirection v1_Axis1, ::Ifc4::IfcDirection v2_Axis2, ::Ifc4::IfcCartesianPoint v3_LocalOrigin, std::optional< double > v4_Scale, std::optional< double > v5_Scale2) { set_attribute_value(0, (v1_Axis1));set_attribute_value(1, (v2_Axis2));set_attribute_value(2, (v3_LocalOrigin)); if (v4_Scale) {set_attribute_value(3, (*v4_Scale)); } if (v5_Scale2) {set_attribute_value(4, (*v5_Scale2)); } }
|
|
|
|
// Function implementations for IfcCartesianTransformationOperator3D
|
|
::Ifc4::IfcDirection Ifc4::IfcCartesianTransformationOperator3D::Axis3() const { if(get_attribute_value(4).isNull()) { return ::Ifc4::IfcDirection{}; } return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcDirection>(); }
|
|
void Ifc4::IfcCartesianTransformationOperator3D::setAxis3(const ::Ifc4::IfcDirection& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCartesianTransformationOperator3D::Class() { return *((IfcParse::entity*)IFC4_types[126]); }
|
|
void Ifc4::IfcCartesianTransformationOperator3D::initialize(::Ifc4::IfcDirection v1_Axis1, ::Ifc4::IfcDirection v2_Axis2, ::Ifc4::IfcCartesianPoint v3_LocalOrigin, std::optional< double > v4_Scale, ::Ifc4::IfcDirection v5_Axis3) { set_attribute_value(0, (v1_Axis1));set_attribute_value(1, (v2_Axis2));set_attribute_value(2, (v3_LocalOrigin)); if (v4_Scale) {set_attribute_value(3, (*v4_Scale)); }set_attribute_value(4, (v5_Axis3)); }
|
|
|
|
// Function implementations for IfcCartesianTransformationOperator3DnonUniform
|
|
std::optional< double > Ifc4::IfcCartesianTransformationOperator3DnonUniform::Scale2() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcCartesianTransformationOperator3DnonUniform::setScale2(const std::optional< double >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< double > Ifc4::IfcCartesianTransformationOperator3DnonUniform::Scale3() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcCartesianTransformationOperator3DnonUniform::setScale3(const std::optional< double >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCartesianTransformationOperator3DnonUniform::Class() { return *((IfcParse::entity*)IFC4_types[127]); }
|
|
void Ifc4::IfcCartesianTransformationOperator3DnonUniform::initialize(::Ifc4::IfcDirection v1_Axis1, ::Ifc4::IfcDirection v2_Axis2, ::Ifc4::IfcCartesianPoint v3_LocalOrigin, std::optional< double > v4_Scale, ::Ifc4::IfcDirection v5_Axis3, std::optional< double > v6_Scale2, std::optional< double > v7_Scale3) { set_attribute_value(0, (v1_Axis1));set_attribute_value(1, (v2_Axis2));set_attribute_value(2, (v3_LocalOrigin)); if (v4_Scale) {set_attribute_value(3, (*v4_Scale)); }set_attribute_value(4, (v5_Axis3)); if (v6_Scale2) {set_attribute_value(5, (*v6_Scale2)); } if (v7_Scale3) {set_attribute_value(6, (*v7_Scale3)); } }
|
|
|
|
// Function implementations for IfcCenterLineProfileDef
|
|
double Ifc4::IfcCenterLineProfileDef::Thickness() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcCenterLineProfileDef::setThickness(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCenterLineProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[128]); }
|
|
void Ifc4::IfcCenterLineProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcBoundedCurve v3_Curve, double v4_Thickness) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Curve));set_attribute_value(3, (v4_Thickness)); }
|
|
|
|
// Function implementations for IfcChiller
|
|
std::optional< ::Ifc4::IfcChillerTypeEnum::Value > Ifc4::IfcChiller::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcChillerTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcChiller::setPredefinedType(const std::optional< ::Ifc4::IfcChillerTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcChillerTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcChiller::Class() { return *((IfcParse::entity*)IFC4_types[130]); }
|
|
void Ifc4::IfcChiller::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcChillerTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcChillerTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcChillerType
|
|
::Ifc4::IfcChillerTypeEnum::Value Ifc4::IfcChillerType::PredefinedType() const { return ::Ifc4::IfcChillerTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcChillerType::setPredefinedType(const ::Ifc4::IfcChillerTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcChillerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcChillerType::Class() { return *((IfcParse::entity*)IFC4_types[131]); }
|
|
void Ifc4::IfcChillerType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcChillerTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcChillerTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcChimney
|
|
std::optional< ::Ifc4::IfcChimneyTypeEnum::Value > Ifc4::IfcChimney::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcChimneyTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcChimney::setPredefinedType(const std::optional< ::Ifc4::IfcChimneyTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcChimneyTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcChimney::Class() { return *((IfcParse::entity*)IFC4_types[133]); }
|
|
void Ifc4::IfcChimney::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcChimneyTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcChimneyTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcChimneyType
|
|
::Ifc4::IfcChimneyTypeEnum::Value Ifc4::IfcChimneyType::PredefinedType() const { return ::Ifc4::IfcChimneyTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcChimneyType::setPredefinedType(const ::Ifc4::IfcChimneyTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcChimneyTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcChimneyType::Class() { return *((IfcParse::entity*)IFC4_types[134]); }
|
|
void Ifc4::IfcChimneyType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcChimneyTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcChimneyTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcCircle
|
|
double Ifc4::IfcCircle::Radius() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcCircle::setRadius(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCircle::Class() { return *((IfcParse::entity*)IFC4_types[136]); }
|
|
void Ifc4::IfcCircle::initialize(::Ifc4::IfcAxis2Placement v1_Position, double v2_Radius) { set_attribute_value(0, (v1_Position));set_attribute_value(1, (v2_Radius)); }
|
|
|
|
// Function implementations for IfcCircleHollowProfileDef
|
|
double Ifc4::IfcCircleHollowProfileDef::WallThickness() const { double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcCircleHollowProfileDef::setWallThickness(const double& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCircleHollowProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[137]); }
|
|
void Ifc4::IfcCircleHollowProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcAxis2Placement2D v3_Position, double v4_Radius, double v5_WallThickness) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Position));set_attribute_value(3, (v4_Radius));set_attribute_value(4, (v5_WallThickness)); }
|
|
|
|
// Function implementations for IfcCircleProfileDef
|
|
double Ifc4::IfcCircleProfileDef::Radius() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcCircleProfileDef::setRadius(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCircleProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[138]); }
|
|
void Ifc4::IfcCircleProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcAxis2Placement2D v3_Position, double v4_Radius) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Position));set_attribute_value(3, (v4_Radius)); }
|
|
|
|
// Function implementations for IfcCivilElement
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCivilElement::Class() { return *((IfcParse::entity*)IFC4_types[139]); }
|
|
void Ifc4::IfcCivilElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcCivilElementType
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCivilElementType::Class() { return *((IfcParse::entity*)IFC4_types[140]); }
|
|
void Ifc4::IfcCivilElementType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcClassification
|
|
std::optional< std::string > Ifc4::IfcClassification::Source() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcClassification::setSource(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< std::string > Ifc4::IfcClassification::Edition() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcClassification::setEdition(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< std::string > Ifc4::IfcClassification::EditionDate() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcClassification::setEditionDate(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::string Ifc4::IfcClassification::Name() const { std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcClassification::setName(const std::string& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< std::string > Ifc4::IfcClassification::Description() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcClassification::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcClassification::Location() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcClassification::setLocation(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< std::vector< std::string > /*[1:?]*/ > Ifc4::IfcClassification::ReferenceTokens() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcClassification::setReferenceTokens(const std::optional< std::vector< std::string > /*[1:?]*/ >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
|
|
std::vector<::Ifc4::IfcRelAssociatesClassification> Ifc4::IfcClassification::ClassificationForObjects() const { return cast_vector<IfcRelAssociatesClassification>(file()->getInverse(data()->id(), IFC4_types[808], 5)); }
|
|
std::vector<::Ifc4::IfcClassificationReference> Ifc4::IfcClassification::HasReferences() const { return cast_vector<IfcClassificationReference>(file()->getInverse(data()->id(), IFC4_types[142], 3)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcClassification::Class() { return *((IfcParse::entity*)IFC4_types[141]); }
|
|
void Ifc4::IfcClassification::initialize(std::optional< std::string > v1_Source, std::optional< std::string > v2_Edition, std::optional< std::string > v3_EditionDate, std::string v4_Name, std::optional< std::string > v5_Description, std::optional< std::string > v6_Location, std::optional< std::vector< std::string > /*[1:?]*/ > v7_ReferenceTokens) { if (v1_Source) {set_attribute_value(0, (*v1_Source)); } if (v2_Edition) {set_attribute_value(1, (*v2_Edition)); } if (v3_EditionDate) {set_attribute_value(2, (*v3_EditionDate)); }set_attribute_value(3, (v4_Name)); if (v5_Description) {set_attribute_value(4, (*v5_Description)); } if (v6_Location) {set_attribute_value(5, (*v6_Location)); } if (v7_ReferenceTokens) {set_attribute_value(6, (*v7_ReferenceTokens)); } }
|
|
|
|
// Function implementations for IfcClassificationReference
|
|
::Ifc4::IfcClassificationReferenceSelect Ifc4::IfcClassificationReference::ReferencedSource() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcClassificationReferenceSelect{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcClassificationReferenceSelect>(); }
|
|
void Ifc4::IfcClassificationReference::setReferencedSource(const ::Ifc4::IfcClassificationReferenceSelect& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< std::string > Ifc4::IfcClassificationReference::Description() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcClassificationReference::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcClassificationReference::Sort() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcClassificationReference::setSort(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
|
|
std::vector<::Ifc4::IfcRelAssociatesClassification> Ifc4::IfcClassificationReference::ClassificationRefForObjects() const { return cast_vector<IfcRelAssociatesClassification>(file()->getInverse(data()->id(), IFC4_types[808], 5)); }
|
|
std::vector<::Ifc4::IfcClassificationReference> Ifc4::IfcClassificationReference::HasReferences() const { return cast_vector<IfcClassificationReference>(file()->getInverse(data()->id(), IFC4_types[142], 3)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcClassificationReference::Class() { return *((IfcParse::entity*)IFC4_types[142]); }
|
|
void Ifc4::IfcClassificationReference::initialize(std::optional< std::string > v1_Location, std::optional< std::string > v2_Identification, std::optional< std::string > v3_Name, ::Ifc4::IfcClassificationReferenceSelect v4_ReferencedSource, std::optional< std::string > v5_Description, std::optional< std::string > v6_Sort) { if (v1_Location) {set_attribute_value(0, (*v1_Location)); } if (v2_Identification) {set_attribute_value(1, (*v2_Identification)); } if (v3_Name) {set_attribute_value(2, (*v3_Name)); }set_attribute_value(3, (v4_ReferencedSource)); if (v5_Description) {set_attribute_value(4, (*v5_Description)); } if (v6_Sort) {set_attribute_value(5, (*v6_Sort)); } }
|
|
|
|
// Function implementations for IfcClosedShell
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcClosedShell::Class() { return *((IfcParse::entity*)IFC4_types[145]); }
|
|
void Ifc4::IfcClosedShell::initialize(std::vector< ::Ifc4::IfcFace > v1_CfsFaces) { set_attribute_value(0, cast_vector<express::Base>(v1_CfsFaces)); }
|
|
|
|
// Function implementations for IfcCoil
|
|
std::optional< ::Ifc4::IfcCoilTypeEnum::Value > Ifc4::IfcCoil::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcCoilTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcCoil::setPredefinedType(const std::optional< ::Ifc4::IfcCoilTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcCoilTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCoil::Class() { return *((IfcParse::entity*)IFC4_types[146]); }
|
|
void Ifc4::IfcCoil::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcCoilTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcCoilTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcCoilType
|
|
::Ifc4::IfcCoilTypeEnum::Value Ifc4::IfcCoilType::PredefinedType() const { return ::Ifc4::IfcCoilTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcCoilType::setPredefinedType(const ::Ifc4::IfcCoilTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcCoilTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCoilType::Class() { return *((IfcParse::entity*)IFC4_types[147]); }
|
|
void Ifc4::IfcCoilType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcCoilTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcCoilTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcColourRgb
|
|
double Ifc4::IfcColourRgb::Red() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcColourRgb::setRed(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
double Ifc4::IfcColourRgb::Green() const { double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcColourRgb::setGreen(const double& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
double Ifc4::IfcColourRgb::Blue() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcColourRgb::setBlue(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcColourRgb::Class() { return *((IfcParse::entity*)IFC4_types[151]); }
|
|
void Ifc4::IfcColourRgb::initialize(std::optional< std::string > v1_Name, double v2_Red, double v3_Green, double v4_Blue) { 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)); }
|
|
|
|
// Function implementations for IfcColourRgbList
|
|
std::vector< std::vector< double > > Ifc4::IfcColourRgbList::ColourList() const { std::vector< std::vector< double > > v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcColourRgbList::setColourList(const std::vector< std::vector< double > >& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcColourRgbList::Class() { return *((IfcParse::entity*)IFC4_types[152]); }
|
|
void Ifc4::IfcColourRgbList::initialize(std::vector< std::vector< double > > v1_ColourList) { set_attribute_value(0, (v1_ColourList)); }
|
|
|
|
// Function implementations for IfcColourSpecification
|
|
std::optional< std::string > Ifc4::IfcColourSpecification::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcColourSpecification::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcColourSpecification::Class() { return *((IfcParse::entity*)IFC4_types[153]); }
|
|
void Ifc4::IfcColourSpecification::initialize(std::optional< std::string > v1_Name) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } }
|
|
|
|
// Function implementations for IfcColumn
|
|
std::optional< ::Ifc4::IfcColumnTypeEnum::Value > Ifc4::IfcColumn::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcColumnTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcColumn::setPredefinedType(const std::optional< ::Ifc4::IfcColumnTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcColumnTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcColumn::Class() { return *((IfcParse::entity*)IFC4_types[154]); }
|
|
void Ifc4::IfcColumn::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcColumnTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcColumnTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcColumnStandardCase
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcColumnStandardCase::Class() { return *((IfcParse::entity*)IFC4_types[155]); }
|
|
void Ifc4::IfcColumnStandardCase::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcColumnTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcColumnTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcColumnType
|
|
::Ifc4::IfcColumnTypeEnum::Value Ifc4::IfcColumnType::PredefinedType() const { return ::Ifc4::IfcColumnTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcColumnType::setPredefinedType(const ::Ifc4::IfcColumnTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcColumnTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcColumnType::Class() { return *((IfcParse::entity*)IFC4_types[156]); }
|
|
void Ifc4::IfcColumnType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcColumnTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcColumnTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcCommunicationsAppliance
|
|
std::optional< ::Ifc4::IfcCommunicationsApplianceTypeEnum::Value > Ifc4::IfcCommunicationsAppliance::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcCommunicationsApplianceTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcCommunicationsAppliance::setPredefinedType(const std::optional< ::Ifc4::IfcCommunicationsApplianceTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcCommunicationsApplianceTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCommunicationsAppliance::Class() { return *((IfcParse::entity*)IFC4_types[158]); }
|
|
void Ifc4::IfcCommunicationsAppliance::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcCommunicationsApplianceTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcCommunicationsApplianceTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcCommunicationsApplianceType
|
|
::Ifc4::IfcCommunicationsApplianceTypeEnum::Value Ifc4::IfcCommunicationsApplianceType::PredefinedType() const { return ::Ifc4::IfcCommunicationsApplianceTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcCommunicationsApplianceType::setPredefinedType(const ::Ifc4::IfcCommunicationsApplianceTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcCommunicationsApplianceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCommunicationsApplianceType::Class() { return *((IfcParse::entity*)IFC4_types[159]); }
|
|
void Ifc4::IfcCommunicationsApplianceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcCommunicationsApplianceTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcCommunicationsApplianceTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcComplexProperty
|
|
std::string Ifc4::IfcComplexProperty::UsageName() const { std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcComplexProperty::setUsageName(const std::string& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
std::vector< ::Ifc4::IfcProperty > Ifc4::IfcComplexProperty::HasProperties() const { std::vector<express::Base> es = get_attribute_value(3); return cast_vector<::Ifc4::IfcProperty>(es); }
|
|
void Ifc4::IfcComplexProperty::setHasProperties(const std::vector< ::Ifc4::IfcProperty >& v) { set_attribute_value(3, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcComplexProperty::Class() { return *((IfcParse::entity*)IFC4_types[162]); }
|
|
void Ifc4::IfcComplexProperty::initialize(std::string v1_Name, std::optional< std::string > v2_Description, std::string v3_UsageName, std::vector< ::Ifc4::IfcProperty > v4_HasProperties) { 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, cast_vector<express::Base>(v4_HasProperties)); }
|
|
|
|
// Function implementations for IfcComplexPropertyTemplate
|
|
std::optional< std::string > Ifc4::IfcComplexPropertyTemplate::UsageName() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcComplexPropertyTemplate::setUsageName(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< ::Ifc4::IfcComplexPropertyTemplateTypeEnum::Value > Ifc4::IfcComplexPropertyTemplate::TemplateType() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } return ::Ifc4::IfcComplexPropertyTemplateTypeEnum::FromString(get_attribute_value(5)); }
|
|
void Ifc4::IfcComplexPropertyTemplate::setTemplateType(const std::optional< ::Ifc4::IfcComplexPropertyTemplateTypeEnum::Value >& v) { if (v) {set_attribute_value(5, EnumerationReference(&::Ifc4::IfcComplexPropertyTemplateTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(5);} }
|
|
std::optional< std::vector< ::Ifc4::IfcPropertyTemplate > > Ifc4::IfcComplexPropertyTemplate::HasPropertyTemplates() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(6); return cast_vector<::Ifc4::IfcPropertyTemplate>(es); }
|
|
void Ifc4::IfcComplexPropertyTemplate::setHasPropertyTemplates(const std::optional< std::vector< ::Ifc4::IfcPropertyTemplate > >& v) { if (v) {set_attribute_value(6, cast_vector<express::Base>(*v));} else {unset_attribute_value(6);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcComplexPropertyTemplate::Class() { return *((IfcParse::entity*)IFC4_types[163]); }
|
|
void Ifc4::IfcComplexPropertyTemplate::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_UsageName, std::optional< ::Ifc4::IfcComplexPropertyTemplateTypeEnum::Value > v6_TemplateType, std::optional< std::vector< ::Ifc4::IfcPropertyTemplate > > v7_HasPropertyTemplates) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_UsageName) {set_attribute_value(4, (*v5_UsageName)); } if (v6_TemplateType) {set_attribute_value(5, (EnumerationReference(&::Ifc4::IfcComplexPropertyTemplateTypeEnum::Class(),(size_t)*v6_TemplateType))); } if (v7_HasPropertyTemplates) {set_attribute_value(6, cast_vector<express::Base>(*v7_HasPropertyTemplates)); } }
|
|
|
|
// Function implementations for IfcCompositeCurve
|
|
std::vector< ::Ifc4::IfcCompositeCurveSegment > Ifc4::IfcCompositeCurve::Segments() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcCompositeCurveSegment>(es); }
|
|
void Ifc4::IfcCompositeCurve::setSegments(const std::vector< ::Ifc4::IfcCompositeCurveSegment >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
boost::logic::tribool Ifc4::IfcCompositeCurve::SelfIntersect() const { boost::logic::tribool v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcCompositeCurve::setSelfIntersect(const boost::logic::tribool& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCompositeCurve::Class() { return *((IfcParse::entity*)IFC4_types[165]); }
|
|
void Ifc4::IfcCompositeCurve::initialize(std::vector< ::Ifc4::IfcCompositeCurveSegment > v1_Segments, boost::logic::tribool v2_SelfIntersect) { set_attribute_value(0, cast_vector<express::Base>(v1_Segments));set_attribute_value(1, (v2_SelfIntersect)); }
|
|
|
|
// Function implementations for IfcCompositeCurveOnSurface
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCompositeCurveOnSurface::Class() { return *((IfcParse::entity*)IFC4_types[166]); }
|
|
void Ifc4::IfcCompositeCurveOnSurface::initialize(std::vector< ::Ifc4::IfcCompositeCurveSegment > v1_Segments, boost::logic::tribool v2_SelfIntersect) { set_attribute_value(0, cast_vector<express::Base>(v1_Segments));set_attribute_value(1, (v2_SelfIntersect)); }
|
|
|
|
// Function implementations for IfcCompositeCurveSegment
|
|
::Ifc4::IfcTransitionCode::Value Ifc4::IfcCompositeCurveSegment::Transition() const { return ::Ifc4::IfcTransitionCode::FromString(get_attribute_value(0)); }
|
|
void Ifc4::IfcCompositeCurveSegment::setTransition(const ::Ifc4::IfcTransitionCode::Value& v) { set_attribute_value(0, EnumerationReference(&::Ifc4::IfcTransitionCode::Class(), (size_t) v));if constexpr (false)unset_attribute_value(0); }
|
|
bool Ifc4::IfcCompositeCurveSegment::SameSense() const { bool v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcCompositeCurveSegment::setSameSense(const bool& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcCurve Ifc4::IfcCompositeCurveSegment::ParentCurve() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcCurve>(); }
|
|
void Ifc4::IfcCompositeCurveSegment::setParentCurve(const ::Ifc4::IfcCurve& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
std::vector<::Ifc4::IfcCompositeCurve> Ifc4::IfcCompositeCurveSegment::UsingCurves() const { return cast_vector<IfcCompositeCurve>(file()->getInverse(data()->id(), IFC4_types[165], 0)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcCompositeCurveSegment::Class() { return *((IfcParse::entity*)IFC4_types[167]); }
|
|
void Ifc4::IfcCompositeCurveSegment::initialize(::Ifc4::IfcTransitionCode::Value v1_Transition, bool v2_SameSense, ::Ifc4::IfcCurve v3_ParentCurve) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcTransitionCode::Class(),(size_t)v1_Transition)));set_attribute_value(1, (v2_SameSense));set_attribute_value(2, (v3_ParentCurve)); }
|
|
|
|
// Function implementations for IfcCompositeProfileDef
|
|
std::vector< ::Ifc4::IfcProfileDef > Ifc4::IfcCompositeProfileDef::Profiles() const { std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcProfileDef>(es); }
|
|
void Ifc4::IfcCompositeProfileDef::setProfiles(const std::vector< ::Ifc4::IfcProfileDef >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
|
|
std::optional< std::string > Ifc4::IfcCompositeProfileDef::Label() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcCompositeProfileDef::setLabel(const std::optional< std::string >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCompositeProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[168]); }
|
|
void Ifc4::IfcCompositeProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, std::vector< ::Ifc4::IfcProfileDef > v3_Profiles, std::optional< std::string > v4_Label) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, cast_vector<express::Base>(v3_Profiles)); if (v4_Label) {set_attribute_value(3, (*v4_Label)); } }
|
|
|
|
// Function implementations for IfcCompressor
|
|
std::optional< ::Ifc4::IfcCompressorTypeEnum::Value > Ifc4::IfcCompressor::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcCompressorTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcCompressor::setPredefinedType(const std::optional< ::Ifc4::IfcCompressorTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcCompressorTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCompressor::Class() { return *((IfcParse::entity*)IFC4_types[170]); }
|
|
void Ifc4::IfcCompressor::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcCompressorTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcCompressorTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcCompressorType
|
|
::Ifc4::IfcCompressorTypeEnum::Value Ifc4::IfcCompressorType::PredefinedType() const { return ::Ifc4::IfcCompressorTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcCompressorType::setPredefinedType(const ::Ifc4::IfcCompressorTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcCompressorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCompressorType::Class() { return *((IfcParse::entity*)IFC4_types[171]); }
|
|
void Ifc4::IfcCompressorType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcCompressorTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcCompressorTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcCondenser
|
|
std::optional< ::Ifc4::IfcCondenserTypeEnum::Value > Ifc4::IfcCondenser::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcCondenserTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcCondenser::setPredefinedType(const std::optional< ::Ifc4::IfcCondenserTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcCondenserTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCondenser::Class() { return *((IfcParse::entity*)IFC4_types[173]); }
|
|
void Ifc4::IfcCondenser::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcCondenserTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcCondenserTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcCondenserType
|
|
::Ifc4::IfcCondenserTypeEnum::Value Ifc4::IfcCondenserType::PredefinedType() const { return ::Ifc4::IfcCondenserTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcCondenserType::setPredefinedType(const ::Ifc4::IfcCondenserTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcCondenserTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCondenserType::Class() { return *((IfcParse::entity*)IFC4_types[174]); }
|
|
void Ifc4::IfcCondenserType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcCondenserTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcCondenserTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcConic
|
|
::Ifc4::IfcAxis2Placement Ifc4::IfcConic::Position() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcAxis2Placement>(); }
|
|
void Ifc4::IfcConic::setPosition(const ::Ifc4::IfcAxis2Placement& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcConic::Class() { return *((IfcParse::entity*)IFC4_types[176]); }
|
|
void Ifc4::IfcConic::initialize(::Ifc4::IfcAxis2Placement v1_Position) { set_attribute_value(0, (v1_Position)); }
|
|
|
|
// Function implementations for IfcConnectedFaceSet
|
|
std::vector< ::Ifc4::IfcFace > Ifc4::IfcConnectedFaceSet::CfsFaces() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcFace>(es); }
|
|
void Ifc4::IfcConnectedFaceSet::setCfsFaces(const std::vector< ::Ifc4::IfcFace >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcConnectedFaceSet::Class() { return *((IfcParse::entity*)IFC4_types[177]); }
|
|
void Ifc4::IfcConnectedFaceSet::initialize(std::vector< ::Ifc4::IfcFace > v1_CfsFaces) { set_attribute_value(0, cast_vector<express::Base>(v1_CfsFaces)); }
|
|
|
|
// Function implementations for IfcConnectionCurveGeometry
|
|
::Ifc4::IfcCurveOrEdgeCurve Ifc4::IfcConnectionCurveGeometry::CurveOnRelatingElement() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcCurveOrEdgeCurve>(); }
|
|
void Ifc4::IfcConnectionCurveGeometry::setCurveOnRelatingElement(const ::Ifc4::IfcCurveOrEdgeCurve& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcCurveOrEdgeCurve Ifc4::IfcConnectionCurveGeometry::CurveOnRelatedElement() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcCurveOrEdgeCurve{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcCurveOrEdgeCurve>(); }
|
|
void Ifc4::IfcConnectionCurveGeometry::setCurveOnRelatedElement(const ::Ifc4::IfcCurveOrEdgeCurve& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcConnectionCurveGeometry::Class() { return *((IfcParse::entity*)IFC4_types[178]); }
|
|
void Ifc4::IfcConnectionCurveGeometry::initialize(::Ifc4::IfcCurveOrEdgeCurve v1_CurveOnRelatingElement, ::Ifc4::IfcCurveOrEdgeCurve v2_CurveOnRelatedElement) { set_attribute_value(0, (v1_CurveOnRelatingElement));set_attribute_value(1, (v2_CurveOnRelatedElement)); }
|
|
|
|
// Function implementations for IfcConnectionGeometry
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcConnectionGeometry::Class() { return *((IfcParse::entity*)IFC4_types[179]); }
|
|
void Ifc4::IfcConnectionGeometry::initialize() { }
|
|
|
|
// Function implementations for IfcConnectionPointEccentricity
|
|
std::optional< double > Ifc4::IfcConnectionPointEccentricity::EccentricityInX() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcConnectionPointEccentricity::setEccentricityInX(const std::optional< double >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< double > Ifc4::IfcConnectionPointEccentricity::EccentricityInY() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcConnectionPointEccentricity::setEccentricityInY(const std::optional< double >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< double > Ifc4::IfcConnectionPointEccentricity::EccentricityInZ() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcConnectionPointEccentricity::setEccentricityInZ(const std::optional< double >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcConnectionPointEccentricity::Class() { return *((IfcParse::entity*)IFC4_types[180]); }
|
|
void Ifc4::IfcConnectionPointEccentricity::initialize(::Ifc4::IfcPointOrVertexPoint v1_PointOnRelatingElement, ::Ifc4::IfcPointOrVertexPoint v2_PointOnRelatedElement, std::optional< double > v3_EccentricityInX, std::optional< double > v4_EccentricityInY, std::optional< double > v5_EccentricityInZ) { set_attribute_value(0, (v1_PointOnRelatingElement));set_attribute_value(1, (v2_PointOnRelatedElement)); 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)); } }
|
|
|
|
// Function implementations for IfcConnectionPointGeometry
|
|
::Ifc4::IfcPointOrVertexPoint Ifc4::IfcConnectionPointGeometry::PointOnRelatingElement() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcPointOrVertexPoint>(); }
|
|
void Ifc4::IfcConnectionPointGeometry::setPointOnRelatingElement(const ::Ifc4::IfcPointOrVertexPoint& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcPointOrVertexPoint Ifc4::IfcConnectionPointGeometry::PointOnRelatedElement() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcPointOrVertexPoint{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcPointOrVertexPoint>(); }
|
|
void Ifc4::IfcConnectionPointGeometry::setPointOnRelatedElement(const ::Ifc4::IfcPointOrVertexPoint& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcConnectionPointGeometry::Class() { return *((IfcParse::entity*)IFC4_types[181]); }
|
|
void Ifc4::IfcConnectionPointGeometry::initialize(::Ifc4::IfcPointOrVertexPoint v1_PointOnRelatingElement, ::Ifc4::IfcPointOrVertexPoint v2_PointOnRelatedElement) { set_attribute_value(0, (v1_PointOnRelatingElement));set_attribute_value(1, (v2_PointOnRelatedElement)); }
|
|
|
|
// Function implementations for IfcConnectionSurfaceGeometry
|
|
::Ifc4::IfcSurfaceOrFaceSurface Ifc4::IfcConnectionSurfaceGeometry::SurfaceOnRelatingElement() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcSurfaceOrFaceSurface>(); }
|
|
void Ifc4::IfcConnectionSurfaceGeometry::setSurfaceOnRelatingElement(const ::Ifc4::IfcSurfaceOrFaceSurface& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcSurfaceOrFaceSurface Ifc4::IfcConnectionSurfaceGeometry::SurfaceOnRelatedElement() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcSurfaceOrFaceSurface{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcSurfaceOrFaceSurface>(); }
|
|
void Ifc4::IfcConnectionSurfaceGeometry::setSurfaceOnRelatedElement(const ::Ifc4::IfcSurfaceOrFaceSurface& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcConnectionSurfaceGeometry::Class() { return *((IfcParse::entity*)IFC4_types[182]); }
|
|
void Ifc4::IfcConnectionSurfaceGeometry::initialize(::Ifc4::IfcSurfaceOrFaceSurface v1_SurfaceOnRelatingElement, ::Ifc4::IfcSurfaceOrFaceSurface v2_SurfaceOnRelatedElement) { set_attribute_value(0, (v1_SurfaceOnRelatingElement));set_attribute_value(1, (v2_SurfaceOnRelatedElement)); }
|
|
|
|
// Function implementations for IfcConnectionVolumeGeometry
|
|
::Ifc4::IfcSolidOrShell Ifc4::IfcConnectionVolumeGeometry::VolumeOnRelatingElement() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcSolidOrShell>(); }
|
|
void Ifc4::IfcConnectionVolumeGeometry::setVolumeOnRelatingElement(const ::Ifc4::IfcSolidOrShell& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcSolidOrShell Ifc4::IfcConnectionVolumeGeometry::VolumeOnRelatedElement() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcSolidOrShell{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcSolidOrShell>(); }
|
|
void Ifc4::IfcConnectionVolumeGeometry::setVolumeOnRelatedElement(const ::Ifc4::IfcSolidOrShell& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcConnectionVolumeGeometry::Class() { return *((IfcParse::entity*)IFC4_types[184]); }
|
|
void Ifc4::IfcConnectionVolumeGeometry::initialize(::Ifc4::IfcSolidOrShell v1_VolumeOnRelatingElement, ::Ifc4::IfcSolidOrShell v2_VolumeOnRelatedElement) { set_attribute_value(0, (v1_VolumeOnRelatingElement));set_attribute_value(1, (v2_VolumeOnRelatedElement)); }
|
|
|
|
// Function implementations for IfcConstraint
|
|
std::string Ifc4::IfcConstraint::Name() const { std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcConstraint::setName(const std::string& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< std::string > Ifc4::IfcConstraint::Description() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcConstraint::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
::Ifc4::IfcConstraintEnum::Value Ifc4::IfcConstraint::ConstraintGrade() const { return ::Ifc4::IfcConstraintEnum::FromString(get_attribute_value(2)); }
|
|
void Ifc4::IfcConstraint::setConstraintGrade(const ::Ifc4::IfcConstraintEnum::Value& v) { set_attribute_value(2, EnumerationReference(&::Ifc4::IfcConstraintEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(2); }
|
|
std::optional< std::string > Ifc4::IfcConstraint::ConstraintSource() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcConstraint::setConstraintSource(const std::optional< std::string >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
::Ifc4::IfcActorSelect Ifc4::IfcConstraint::CreatingActor() const { if(get_attribute_value(4).isNull()) { return ::Ifc4::IfcActorSelect{}; } return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcActorSelect>(); }
|
|
void Ifc4::IfcConstraint::setCreatingActor(const ::Ifc4::IfcActorSelect& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
std::optional< std::string > Ifc4::IfcConstraint::CreationTime() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcConstraint::setCreationTime(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< std::string > Ifc4::IfcConstraint::UserDefinedGrade() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcConstraint::setUserDefinedGrade(const std::optional< std::string >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
|
|
std::vector<::Ifc4::IfcExternalReferenceRelationship> Ifc4::IfcConstraint::HasExternalReferences() const { return cast_vector<IfcExternalReferenceRelationship>(file()->getInverse(data()->id(), IFC4_types[380], 3)); }
|
|
std::vector<::Ifc4::IfcResourceConstraintRelationship> Ifc4::IfcConstraint::PropertiesForConstraint() const { return cast_vector<IfcResourceConstraintRelationship>(file()->getInverse(data()->id(), IFC4_types[852], 2)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcConstraint::Class() { return *((IfcParse::entity*)IFC4_types[185]); }
|
|
void Ifc4::IfcConstraint::initialize(std::string v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcConstraintEnum::Value v3_ConstraintGrade, std::optional< std::string > v4_ConstraintSource, ::Ifc4::IfcActorSelect v5_CreatingActor, std::optional< std::string > v6_CreationTime, std::optional< std::string > v7_UserDefinedGrade) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (EnumerationReference(&::Ifc4::IfcConstraintEnum::Class(),(size_t)v3_ConstraintGrade))); if (v4_ConstraintSource) {set_attribute_value(3, (*v4_ConstraintSource)); }set_attribute_value(4, (v5_CreatingActor)); if (v6_CreationTime) {set_attribute_value(5, (*v6_CreationTime)); } if (v7_UserDefinedGrade) {set_attribute_value(6, (*v7_UserDefinedGrade)); } }
|
|
|
|
// Function implementations for IfcConstructionEquipmentResource
|
|
std::optional< ::Ifc4::IfcConstructionEquipmentResourceTypeEnum::Value > Ifc4::IfcConstructionEquipmentResource::PredefinedType() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } return ::Ifc4::IfcConstructionEquipmentResourceTypeEnum::FromString(get_attribute_value(10)); }
|
|
void Ifc4::IfcConstructionEquipmentResource::setPredefinedType(const std::optional< ::Ifc4::IfcConstructionEquipmentResourceTypeEnum::Value >& v) { if (v) {set_attribute_value(10, EnumerationReference(&::Ifc4::IfcConstructionEquipmentResourceTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(10);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcConstructionEquipmentResource::Class() { return *((IfcParse::entity*)IFC4_types[187]); }
|
|
void Ifc4::IfcConstructionEquipmentResource::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< std::string > v7_LongDescription, ::Ifc4::IfcResourceTime v8_Usage, std::optional< std::vector< ::Ifc4::IfcAppliedValue > > v9_BaseCosts, ::Ifc4::IfcPhysicalQuantity v10_BaseQuantity, std::optional< ::Ifc4::IfcConstructionEquipmentResourceTypeEnum::Value > v11_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_LongDescription) {set_attribute_value(6, (*v7_LongDescription)); }set_attribute_value(7, (v8_Usage)); if (v9_BaseCosts) {set_attribute_value(8, cast_vector<express::Base>(*v9_BaseCosts)); }set_attribute_value(9, (v10_BaseQuantity)); if (v11_PredefinedType) {set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcConstructionEquipmentResourceTypeEnum::Class(),(size_t)*v11_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcConstructionEquipmentResourceType
|
|
::Ifc4::IfcConstructionEquipmentResourceTypeEnum::Value Ifc4::IfcConstructionEquipmentResourceType::PredefinedType() const { return ::Ifc4::IfcConstructionEquipmentResourceTypeEnum::FromString(get_attribute_value(11)); }
|
|
void Ifc4::IfcConstructionEquipmentResourceType::setPredefinedType(const ::Ifc4::IfcConstructionEquipmentResourceTypeEnum::Value& v) { set_attribute_value(11, EnumerationReference(&::Ifc4::IfcConstructionEquipmentResourceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(11); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcConstructionEquipmentResourceType::Class() { return *((IfcParse::entity*)IFC4_types[188]); }
|
|
void Ifc4::IfcConstructionEquipmentResourceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::string > v7_Identification, std::optional< std::string > v8_LongDescription, std::optional< std::string > v9_ResourceType, std::optional< std::vector< ::Ifc4::IfcAppliedValue > > v10_BaseCosts, ::Ifc4::IfcPhysicalQuantity v11_BaseQuantity, ::Ifc4::IfcConstructionEquipmentResourceTypeEnum::Value v12_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_Identification) {set_attribute_value(6, (*v7_Identification)); } if (v8_LongDescription) {set_attribute_value(7, (*v8_LongDescription)); } if (v9_ResourceType) {set_attribute_value(8, (*v9_ResourceType)); } if (v10_BaseCosts) {set_attribute_value(9, cast_vector<express::Base>(*v10_BaseCosts)); }set_attribute_value(10, (v11_BaseQuantity));set_attribute_value(11, (EnumerationReference(&::Ifc4::IfcConstructionEquipmentResourceTypeEnum::Class(),(size_t)v12_PredefinedType))); }
|
|
|
|
// Function implementations for IfcConstructionMaterialResource
|
|
std::optional< ::Ifc4::IfcConstructionMaterialResourceTypeEnum::Value > Ifc4::IfcConstructionMaterialResource::PredefinedType() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } return ::Ifc4::IfcConstructionMaterialResourceTypeEnum::FromString(get_attribute_value(10)); }
|
|
void Ifc4::IfcConstructionMaterialResource::setPredefinedType(const std::optional< ::Ifc4::IfcConstructionMaterialResourceTypeEnum::Value >& v) { if (v) {set_attribute_value(10, EnumerationReference(&::Ifc4::IfcConstructionMaterialResourceTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(10);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcConstructionMaterialResource::Class() { return *((IfcParse::entity*)IFC4_types[190]); }
|
|
void Ifc4::IfcConstructionMaterialResource::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< std::string > v7_LongDescription, ::Ifc4::IfcResourceTime v8_Usage, std::optional< std::vector< ::Ifc4::IfcAppliedValue > > v9_BaseCosts, ::Ifc4::IfcPhysicalQuantity v10_BaseQuantity, std::optional< ::Ifc4::IfcConstructionMaterialResourceTypeEnum::Value > v11_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_LongDescription) {set_attribute_value(6, (*v7_LongDescription)); }set_attribute_value(7, (v8_Usage)); if (v9_BaseCosts) {set_attribute_value(8, cast_vector<express::Base>(*v9_BaseCosts)); }set_attribute_value(9, (v10_BaseQuantity)); if (v11_PredefinedType) {set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcConstructionMaterialResourceTypeEnum::Class(),(size_t)*v11_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcConstructionMaterialResourceType
|
|
::Ifc4::IfcConstructionMaterialResourceTypeEnum::Value Ifc4::IfcConstructionMaterialResourceType::PredefinedType() const { return ::Ifc4::IfcConstructionMaterialResourceTypeEnum::FromString(get_attribute_value(11)); }
|
|
void Ifc4::IfcConstructionMaterialResourceType::setPredefinedType(const ::Ifc4::IfcConstructionMaterialResourceTypeEnum::Value& v) { set_attribute_value(11, EnumerationReference(&::Ifc4::IfcConstructionMaterialResourceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(11); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcConstructionMaterialResourceType::Class() { return *((IfcParse::entity*)IFC4_types[191]); }
|
|
void Ifc4::IfcConstructionMaterialResourceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::string > v7_Identification, std::optional< std::string > v8_LongDescription, std::optional< std::string > v9_ResourceType, std::optional< std::vector< ::Ifc4::IfcAppliedValue > > v10_BaseCosts, ::Ifc4::IfcPhysicalQuantity v11_BaseQuantity, ::Ifc4::IfcConstructionMaterialResourceTypeEnum::Value v12_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_Identification) {set_attribute_value(6, (*v7_Identification)); } if (v8_LongDescription) {set_attribute_value(7, (*v8_LongDescription)); } if (v9_ResourceType) {set_attribute_value(8, (*v9_ResourceType)); } if (v10_BaseCosts) {set_attribute_value(9, cast_vector<express::Base>(*v10_BaseCosts)); }set_attribute_value(10, (v11_BaseQuantity));set_attribute_value(11, (EnumerationReference(&::Ifc4::IfcConstructionMaterialResourceTypeEnum::Class(),(size_t)v12_PredefinedType))); }
|
|
|
|
// Function implementations for IfcConstructionProductResource
|
|
std::optional< ::Ifc4::IfcConstructionProductResourceTypeEnum::Value > Ifc4::IfcConstructionProductResource::PredefinedType() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } return ::Ifc4::IfcConstructionProductResourceTypeEnum::FromString(get_attribute_value(10)); }
|
|
void Ifc4::IfcConstructionProductResource::setPredefinedType(const std::optional< ::Ifc4::IfcConstructionProductResourceTypeEnum::Value >& v) { if (v) {set_attribute_value(10, EnumerationReference(&::Ifc4::IfcConstructionProductResourceTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(10);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcConstructionProductResource::Class() { return *((IfcParse::entity*)IFC4_types[193]); }
|
|
void Ifc4::IfcConstructionProductResource::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< std::string > v7_LongDescription, ::Ifc4::IfcResourceTime v8_Usage, std::optional< std::vector< ::Ifc4::IfcAppliedValue > > v9_BaseCosts, ::Ifc4::IfcPhysicalQuantity v10_BaseQuantity, std::optional< ::Ifc4::IfcConstructionProductResourceTypeEnum::Value > v11_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_LongDescription) {set_attribute_value(6, (*v7_LongDescription)); }set_attribute_value(7, (v8_Usage)); if (v9_BaseCosts) {set_attribute_value(8, cast_vector<express::Base>(*v9_BaseCosts)); }set_attribute_value(9, (v10_BaseQuantity)); if (v11_PredefinedType) {set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcConstructionProductResourceTypeEnum::Class(),(size_t)*v11_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcConstructionProductResourceType
|
|
::Ifc4::IfcConstructionProductResourceTypeEnum::Value Ifc4::IfcConstructionProductResourceType::PredefinedType() const { return ::Ifc4::IfcConstructionProductResourceTypeEnum::FromString(get_attribute_value(11)); }
|
|
void Ifc4::IfcConstructionProductResourceType::setPredefinedType(const ::Ifc4::IfcConstructionProductResourceTypeEnum::Value& v) { set_attribute_value(11, EnumerationReference(&::Ifc4::IfcConstructionProductResourceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(11); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcConstructionProductResourceType::Class() { return *((IfcParse::entity*)IFC4_types[194]); }
|
|
void Ifc4::IfcConstructionProductResourceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::string > v7_Identification, std::optional< std::string > v8_LongDescription, std::optional< std::string > v9_ResourceType, std::optional< std::vector< ::Ifc4::IfcAppliedValue > > v10_BaseCosts, ::Ifc4::IfcPhysicalQuantity v11_BaseQuantity, ::Ifc4::IfcConstructionProductResourceTypeEnum::Value v12_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_Identification) {set_attribute_value(6, (*v7_Identification)); } if (v8_LongDescription) {set_attribute_value(7, (*v8_LongDescription)); } if (v9_ResourceType) {set_attribute_value(8, (*v9_ResourceType)); } if (v10_BaseCosts) {set_attribute_value(9, cast_vector<express::Base>(*v10_BaseCosts)); }set_attribute_value(10, (v11_BaseQuantity));set_attribute_value(11, (EnumerationReference(&::Ifc4::IfcConstructionProductResourceTypeEnum::Class(),(size_t)v12_PredefinedType))); }
|
|
|
|
// Function implementations for IfcConstructionResource
|
|
::Ifc4::IfcResourceTime Ifc4::IfcConstructionResource::Usage() const { if(get_attribute_value(7).isNull()) { return ::Ifc4::IfcResourceTime{}; } return ((express::Base)(get_attribute_value(7))).as<::Ifc4::IfcResourceTime>(); }
|
|
void Ifc4::IfcConstructionResource::setUsage(const ::Ifc4::IfcResourceTime& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
std::optional< std::vector< ::Ifc4::IfcAppliedValue > > Ifc4::IfcConstructionResource::BaseCosts() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(8); return cast_vector<::Ifc4::IfcAppliedValue>(es); }
|
|
void Ifc4::IfcConstructionResource::setBaseCosts(const std::optional< std::vector< ::Ifc4::IfcAppliedValue > >& v) { if (v) {set_attribute_value(8, cast_vector<express::Base>(*v));} else {unset_attribute_value(8);} }
|
|
::Ifc4::IfcPhysicalQuantity Ifc4::IfcConstructionResource::BaseQuantity() const { if(get_attribute_value(9).isNull()) { return ::Ifc4::IfcPhysicalQuantity{}; } return ((express::Base)(get_attribute_value(9))).as<::Ifc4::IfcPhysicalQuantity>(); }
|
|
void Ifc4::IfcConstructionResource::setBaseQuantity(const ::Ifc4::IfcPhysicalQuantity& v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcConstructionResource::Class() { return *((IfcParse::entity*)IFC4_types[196]); }
|
|
void Ifc4::IfcConstructionResource::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< std::string > v7_LongDescription, ::Ifc4::IfcResourceTime v8_Usage, std::optional< std::vector< ::Ifc4::IfcAppliedValue > > v9_BaseCosts, ::Ifc4::IfcPhysicalQuantity v10_BaseQuantity) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_LongDescription) {set_attribute_value(6, (*v7_LongDescription)); }set_attribute_value(7, (v8_Usage)); if (v9_BaseCosts) {set_attribute_value(8, cast_vector<express::Base>(*v9_BaseCosts)); }set_attribute_value(9, (v10_BaseQuantity)); }
|
|
|
|
// Function implementations for IfcConstructionResourceType
|
|
std::optional< std::vector< ::Ifc4::IfcAppliedValue > > Ifc4::IfcConstructionResourceType::BaseCosts() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(9); return cast_vector<::Ifc4::IfcAppliedValue>(es); }
|
|
void Ifc4::IfcConstructionResourceType::setBaseCosts(const std::optional< std::vector< ::Ifc4::IfcAppliedValue > >& v) { if (v) {set_attribute_value(9, cast_vector<express::Base>(*v));} else {unset_attribute_value(9);} }
|
|
::Ifc4::IfcPhysicalQuantity Ifc4::IfcConstructionResourceType::BaseQuantity() const { if(get_attribute_value(10).isNull()) { return ::Ifc4::IfcPhysicalQuantity{}; } return ((express::Base)(get_attribute_value(10))).as<::Ifc4::IfcPhysicalQuantity>(); }
|
|
void Ifc4::IfcConstructionResourceType::setBaseQuantity(const ::Ifc4::IfcPhysicalQuantity& v) { set_attribute_value(10, v);if constexpr (false)unset_attribute_value(10); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcConstructionResourceType::Class() { return *((IfcParse::entity*)IFC4_types[197]); }
|
|
void Ifc4::IfcConstructionResourceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::string > v7_Identification, std::optional< std::string > v8_LongDescription, std::optional< std::string > v9_ResourceType, std::optional< std::vector< ::Ifc4::IfcAppliedValue > > v10_BaseCosts, ::Ifc4::IfcPhysicalQuantity v11_BaseQuantity) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_Identification) {set_attribute_value(6, (*v7_Identification)); } if (v8_LongDescription) {set_attribute_value(7, (*v8_LongDescription)); } if (v9_ResourceType) {set_attribute_value(8, (*v9_ResourceType)); } if (v10_BaseCosts) {set_attribute_value(9, cast_vector<express::Base>(*v10_BaseCosts)); }set_attribute_value(10, (v11_BaseQuantity)); }
|
|
|
|
// Function implementations for IfcContext
|
|
std::optional< std::string > Ifc4::IfcContext::ObjectType() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcContext::setObjectType(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcContext::LongName() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcContext::setLongName(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< std::string > Ifc4::IfcContext::Phase() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcContext::setPhase(const std::optional< std::string >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
std::optional< std::vector< ::Ifc4::IfcRepresentationContext > > Ifc4::IfcContext::RepresentationContexts() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(7); return cast_vector<::Ifc4::IfcRepresentationContext>(es); }
|
|
void Ifc4::IfcContext::setRepresentationContexts(const std::optional< std::vector< ::Ifc4::IfcRepresentationContext > >& v) { if (v) {set_attribute_value(7, cast_vector<express::Base>(*v));} else {unset_attribute_value(7);} }
|
|
::Ifc4::IfcUnitAssignment Ifc4::IfcContext::UnitsInContext() const { if(get_attribute_value(8).isNull()) { return ::Ifc4::IfcUnitAssignment{}; } return ((express::Base)(get_attribute_value(8))).as<::Ifc4::IfcUnitAssignment>(); }
|
|
void Ifc4::IfcContext::setUnitsInContext(const ::Ifc4::IfcUnitAssignment& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
|
|
std::vector<::Ifc4::IfcRelDefinesByProperties> Ifc4::IfcContext::IsDefinedBy() const { return cast_vector<IfcRelDefinesByProperties>(file()->getInverse(data()->id(), IFC4_types[830], 4)); }
|
|
std::vector<::Ifc4::IfcRelDeclares> Ifc4::IfcContext::Declares() const { return cast_vector<IfcRelDeclares>(file()->getInverse(data()->id(), IFC4_types[826], 4)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcContext::Class() { return *((IfcParse::entity*)IFC4_types[198]); }
|
|
void Ifc4::IfcContext::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_LongName, std::optional< std::string > v7_Phase, std::optional< std::vector< ::Ifc4::IfcRepresentationContext > > v8_RepresentationContexts, ::Ifc4::IfcUnitAssignment v9_UnitsInContext) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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)); } if (v8_RepresentationContexts) {set_attribute_value(7, cast_vector<express::Base>(*v8_RepresentationContexts)); }set_attribute_value(8, (v9_UnitsInContext)); }
|
|
|
|
// Function implementations for IfcContextDependentUnit
|
|
std::string Ifc4::IfcContextDependentUnit::Name() const { std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcContextDependentUnit::setName(const std::string& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
std::vector<::Ifc4::IfcExternalReferenceRelationship> Ifc4::IfcContextDependentUnit::HasExternalReference() const { return cast_vector<IfcExternalReferenceRelationship>(file()->getInverse(data()->id(), IFC4_types[380], 3)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcContextDependentUnit::Class() { return *((IfcParse::entity*)IFC4_types[200]); }
|
|
void Ifc4::IfcContextDependentUnit::initialize(::Ifc4::IfcDimensionalExponents v1_Dimensions, ::Ifc4::IfcUnitEnum::Value v2_UnitType, std::string v3_Name) { set_attribute_value(0, (v1_Dimensions));set_attribute_value(1, (EnumerationReference(&::Ifc4::IfcUnitEnum::Class(),(size_t)v2_UnitType)));set_attribute_value(2, (v3_Name)); }
|
|
|
|
// Function implementations for IfcControl
|
|
std::optional< std::string > Ifc4::IfcControl::Identification() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcControl::setIdentification(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
|
|
std::vector<::Ifc4::IfcRelAssignsToControl> Ifc4::IfcControl::Controls() const { return cast_vector<IfcRelAssignsToControl>(file()->getInverse(data()->id(), IFC4_types[800], 6)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcControl::Class() { return *((IfcParse::entity*)IFC4_types[201]); }
|
|
void Ifc4::IfcControl::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } }
|
|
|
|
// Function implementations for IfcController
|
|
std::optional< ::Ifc4::IfcControllerTypeEnum::Value > Ifc4::IfcController::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcControllerTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcController::setPredefinedType(const std::optional< ::Ifc4::IfcControllerTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcControllerTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcController::Class() { return *((IfcParse::entity*)IFC4_types[202]); }
|
|
void Ifc4::IfcController::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcControllerTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcControllerTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcControllerType
|
|
::Ifc4::IfcControllerTypeEnum::Value Ifc4::IfcControllerType::PredefinedType() const { return ::Ifc4::IfcControllerTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcControllerType::setPredefinedType(const ::Ifc4::IfcControllerTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcControllerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcControllerType::Class() { return *((IfcParse::entity*)IFC4_types[203]); }
|
|
void Ifc4::IfcControllerType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcControllerTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcControllerTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcConversionBasedUnit
|
|
std::string Ifc4::IfcConversionBasedUnit::Name() const { std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcConversionBasedUnit::setName(const std::string& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcMeasureWithUnit Ifc4::IfcConversionBasedUnit::ConversionFactor() const { return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcMeasureWithUnit>(); }
|
|
void Ifc4::IfcConversionBasedUnit::setConversionFactor(const ::Ifc4::IfcMeasureWithUnit& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
std::vector<::Ifc4::IfcExternalReferenceRelationship> Ifc4::IfcConversionBasedUnit::HasExternalReference() const { return cast_vector<IfcExternalReferenceRelationship>(file()->getInverse(data()->id(), IFC4_types[380], 3)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcConversionBasedUnit::Class() { return *((IfcParse::entity*)IFC4_types[205]); }
|
|
void Ifc4::IfcConversionBasedUnit::initialize(::Ifc4::IfcDimensionalExponents v1_Dimensions, ::Ifc4::IfcUnitEnum::Value v2_UnitType, std::string v3_Name, ::Ifc4::IfcMeasureWithUnit v4_ConversionFactor) { set_attribute_value(0, (v1_Dimensions));set_attribute_value(1, (EnumerationReference(&::Ifc4::IfcUnitEnum::Class(),(size_t)v2_UnitType)));set_attribute_value(2, (v3_Name));set_attribute_value(3, (v4_ConversionFactor)); }
|
|
|
|
// Function implementations for IfcConversionBasedUnitWithOffset
|
|
double Ifc4::IfcConversionBasedUnitWithOffset::ConversionOffset() const { double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcConversionBasedUnitWithOffset::setConversionOffset(const double& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcConversionBasedUnitWithOffset::Class() { return *((IfcParse::entity*)IFC4_types[206]); }
|
|
void Ifc4::IfcConversionBasedUnitWithOffset::initialize(::Ifc4::IfcDimensionalExponents v1_Dimensions, ::Ifc4::IfcUnitEnum::Value v2_UnitType, std::string v3_Name, ::Ifc4::IfcMeasureWithUnit v4_ConversionFactor, double v5_ConversionOffset) { set_attribute_value(0, (v1_Dimensions));set_attribute_value(1, (EnumerationReference(&::Ifc4::IfcUnitEnum::Class(),(size_t)v2_UnitType)));set_attribute_value(2, (v3_Name));set_attribute_value(3, (v4_ConversionFactor));set_attribute_value(4, (v5_ConversionOffset)); }
|
|
|
|
// Function implementations for IfcCooledBeam
|
|
std::optional< ::Ifc4::IfcCooledBeamTypeEnum::Value > Ifc4::IfcCooledBeam::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcCooledBeamTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcCooledBeam::setPredefinedType(const std::optional< ::Ifc4::IfcCooledBeamTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcCooledBeamTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCooledBeam::Class() { return *((IfcParse::entity*)IFC4_types[207]); }
|
|
void Ifc4::IfcCooledBeam::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcCooledBeamTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcCooledBeamTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcCooledBeamType
|
|
::Ifc4::IfcCooledBeamTypeEnum::Value Ifc4::IfcCooledBeamType::PredefinedType() const { return ::Ifc4::IfcCooledBeamTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcCooledBeamType::setPredefinedType(const ::Ifc4::IfcCooledBeamTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcCooledBeamTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCooledBeamType::Class() { return *((IfcParse::entity*)IFC4_types[208]); }
|
|
void Ifc4::IfcCooledBeamType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcCooledBeamTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcCooledBeamTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcCoolingTower
|
|
std::optional< ::Ifc4::IfcCoolingTowerTypeEnum::Value > Ifc4::IfcCoolingTower::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcCoolingTowerTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcCoolingTower::setPredefinedType(const std::optional< ::Ifc4::IfcCoolingTowerTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcCoolingTowerTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCoolingTower::Class() { return *((IfcParse::entity*)IFC4_types[210]); }
|
|
void Ifc4::IfcCoolingTower::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcCoolingTowerTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcCoolingTowerTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcCoolingTowerType
|
|
::Ifc4::IfcCoolingTowerTypeEnum::Value Ifc4::IfcCoolingTowerType::PredefinedType() const { return ::Ifc4::IfcCoolingTowerTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcCoolingTowerType::setPredefinedType(const ::Ifc4::IfcCoolingTowerTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcCoolingTowerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCoolingTowerType::Class() { return *((IfcParse::entity*)IFC4_types[211]); }
|
|
void Ifc4::IfcCoolingTowerType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcCoolingTowerTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcCoolingTowerTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcCoordinateOperation
|
|
::Ifc4::IfcCoordinateReferenceSystemSelect Ifc4::IfcCoordinateOperation::SourceCRS() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcCoordinateReferenceSystemSelect>(); }
|
|
void Ifc4::IfcCoordinateOperation::setSourceCRS(const ::Ifc4::IfcCoordinateReferenceSystemSelect& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcCoordinateReferenceSystem Ifc4::IfcCoordinateOperation::TargetCRS() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcCoordinateReferenceSystem>(); }
|
|
void Ifc4::IfcCoordinateOperation::setTargetCRS(const ::Ifc4::IfcCoordinateReferenceSystem& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCoordinateOperation::Class() { return *((IfcParse::entity*)IFC4_types[213]); }
|
|
void Ifc4::IfcCoordinateOperation::initialize(::Ifc4::IfcCoordinateReferenceSystemSelect v1_SourceCRS, ::Ifc4::IfcCoordinateReferenceSystem v2_TargetCRS) { set_attribute_value(0, (v1_SourceCRS));set_attribute_value(1, (v2_TargetCRS)); }
|
|
|
|
// Function implementations for IfcCoordinateReferenceSystem
|
|
std::string Ifc4::IfcCoordinateReferenceSystem::Name() const { std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcCoordinateReferenceSystem::setName(const std::string& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< std::string > Ifc4::IfcCoordinateReferenceSystem::Description() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcCoordinateReferenceSystem::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< std::string > Ifc4::IfcCoordinateReferenceSystem::GeodeticDatum() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcCoordinateReferenceSystem::setGeodeticDatum(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< std::string > Ifc4::IfcCoordinateReferenceSystem::VerticalDatum() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcCoordinateReferenceSystem::setVerticalDatum(const std::optional< std::string >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
|
|
std::vector<::Ifc4::IfcCoordinateOperation> Ifc4::IfcCoordinateReferenceSystem::HasCoordinateOperation() const { return cast_vector<IfcCoordinateOperation>(file()->getInverse(data()->id(), IFC4_types[213], 0)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcCoordinateReferenceSystem::Class() { return *((IfcParse::entity*)IFC4_types[214]); }
|
|
void Ifc4::IfcCoordinateReferenceSystem::initialize(std::string v1_Name, std::optional< std::string > v2_Description, std::optional< std::string > v3_GeodeticDatum, std::optional< std::string > v4_VerticalDatum) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); } if (v3_GeodeticDatum) {set_attribute_value(2, (*v3_GeodeticDatum)); } if (v4_VerticalDatum) {set_attribute_value(3, (*v4_VerticalDatum)); } }
|
|
|
|
// Function implementations for IfcCostItem
|
|
std::optional< ::Ifc4::IfcCostItemTypeEnum::Value > Ifc4::IfcCostItem::PredefinedType() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } return ::Ifc4::IfcCostItemTypeEnum::FromString(get_attribute_value(6)); }
|
|
void Ifc4::IfcCostItem::setPredefinedType(const std::optional< ::Ifc4::IfcCostItemTypeEnum::Value >& v) { if (v) {set_attribute_value(6, EnumerationReference(&::Ifc4::IfcCostItemTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(6);} }
|
|
std::optional< std::vector< ::Ifc4::IfcCostValue > > Ifc4::IfcCostItem::CostValues() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(7); return cast_vector<::Ifc4::IfcCostValue>(es); }
|
|
void Ifc4::IfcCostItem::setCostValues(const std::optional< std::vector< ::Ifc4::IfcCostValue > >& v) { if (v) {set_attribute_value(7, cast_vector<express::Base>(*v));} else {unset_attribute_value(7);} }
|
|
std::optional< std::vector< ::Ifc4::IfcPhysicalQuantity > > Ifc4::IfcCostItem::CostQuantities() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(8); return cast_vector<::Ifc4::IfcPhysicalQuantity>(es); }
|
|
void Ifc4::IfcCostItem::setCostQuantities(const std::optional< std::vector< ::Ifc4::IfcPhysicalQuantity > >& v) { if (v) {set_attribute_value(8, cast_vector<express::Base>(*v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCostItem::Class() { return *((IfcParse::entity*)IFC4_types[216]); }
|
|
void Ifc4::IfcCostItem::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< ::Ifc4::IfcCostItemTypeEnum::Value > v7_PredefinedType, std::optional< std::vector< ::Ifc4::IfcCostValue > > v8_CostValues, std::optional< std::vector< ::Ifc4::IfcPhysicalQuantity > > v9_CostQuantities) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_PredefinedType) {set_attribute_value(6, (EnumerationReference(&::Ifc4::IfcCostItemTypeEnum::Class(),(size_t)*v7_PredefinedType))); } if (v8_CostValues) {set_attribute_value(7, cast_vector<express::Base>(*v8_CostValues)); } if (v9_CostQuantities) {set_attribute_value(8, cast_vector<express::Base>(*v9_CostQuantities)); } }
|
|
|
|
// Function implementations for IfcCostSchedule
|
|
std::optional< ::Ifc4::IfcCostScheduleTypeEnum::Value > Ifc4::IfcCostSchedule::PredefinedType() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } return ::Ifc4::IfcCostScheduleTypeEnum::FromString(get_attribute_value(6)); }
|
|
void Ifc4::IfcCostSchedule::setPredefinedType(const std::optional< ::Ifc4::IfcCostScheduleTypeEnum::Value >& v) { if (v) {set_attribute_value(6, EnumerationReference(&::Ifc4::IfcCostScheduleTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(6);} }
|
|
std::optional< std::string > Ifc4::IfcCostSchedule::Status() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::string v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcCostSchedule::setStatus(const std::optional< std::string >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< std::string > Ifc4::IfcCostSchedule::SubmittedOn() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcCostSchedule::setSubmittedOn(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
std::optional< std::string > Ifc4::IfcCostSchedule::UpdateDate() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } std::string v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcCostSchedule::setUpdateDate(const std::optional< std::string >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCostSchedule::Class() { return *((IfcParse::entity*)IFC4_types[218]); }
|
|
void Ifc4::IfcCostSchedule::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< ::Ifc4::IfcCostScheduleTypeEnum::Value > v7_PredefinedType, std::optional< std::string > v8_Status, std::optional< std::string > v9_SubmittedOn, std::optional< std::string > v10_UpdateDate) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_PredefinedType) {set_attribute_value(6, (EnumerationReference(&::Ifc4::IfcCostScheduleTypeEnum::Class(),(size_t)*v7_PredefinedType))); } if (v8_Status) {set_attribute_value(7, (*v8_Status)); } if (v9_SubmittedOn) {set_attribute_value(8, (*v9_SubmittedOn)); } if (v10_UpdateDate) {set_attribute_value(9, (*v10_UpdateDate)); } }
|
|
|
|
// Function implementations for IfcCostValue
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCostValue::Class() { return *((IfcParse::entity*)IFC4_types[220]); }
|
|
void Ifc4::IfcCostValue::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcAppliedValueSelect v3_AppliedValue, ::Ifc4::IfcMeasureWithUnit v4_UnitBasis, std::optional< std::string > v5_ApplicableDate, std::optional< std::string > v6_FixedUntilDate, std::optional< std::string > v7_Category, std::optional< std::string > v8_Condition, std::optional< ::Ifc4::IfcArithmeticOperatorEnum::Value > v9_ArithmeticOperator, std::optional< std::vector< ::Ifc4::IfcAppliedValue > > v10_Components) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_AppliedValue));set_attribute_value(3, (v4_UnitBasis)); if (v5_ApplicableDate) {set_attribute_value(4, (*v5_ApplicableDate)); } if (v6_FixedUntilDate) {set_attribute_value(5, (*v6_FixedUntilDate)); } if (v7_Category) {set_attribute_value(6, (*v7_Category)); } if (v8_Condition) {set_attribute_value(7, (*v8_Condition)); } if (v9_ArithmeticOperator) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcArithmeticOperatorEnum::Class(),(size_t)*v9_ArithmeticOperator))); } if (v10_Components) {set_attribute_value(9, cast_vector<express::Base>(*v10_Components)); } }
|
|
|
|
// Function implementations for IfcCovering
|
|
std::optional< ::Ifc4::IfcCoveringTypeEnum::Value > Ifc4::IfcCovering::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcCoveringTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcCovering::setPredefinedType(const std::optional< ::Ifc4::IfcCoveringTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcCoveringTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
std::vector<::Ifc4::IfcRelCoversSpaces> Ifc4::IfcCovering::CoversSpaces() const { return cast_vector<IfcRelCoversSpaces>(file()->getInverse(data()->id(), IFC4_types[825], 5)); }
|
|
std::vector<::Ifc4::IfcRelCoversBldgElements> Ifc4::IfcCovering::CoversElements() const { return cast_vector<IfcRelCoversBldgElements>(file()->getInverse(data()->id(), IFC4_types[824], 5)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcCovering::Class() { return *((IfcParse::entity*)IFC4_types[222]); }
|
|
void Ifc4::IfcCovering::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcCoveringTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcCoveringTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcCoveringType
|
|
::Ifc4::IfcCoveringTypeEnum::Value Ifc4::IfcCoveringType::PredefinedType() const { return ::Ifc4::IfcCoveringTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcCoveringType::setPredefinedType(const ::Ifc4::IfcCoveringTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcCoveringTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCoveringType::Class() { return *((IfcParse::entity*)IFC4_types[223]); }
|
|
void Ifc4::IfcCoveringType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcCoveringTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcCoveringTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcCrewResource
|
|
std::optional< ::Ifc4::IfcCrewResourceTypeEnum::Value > Ifc4::IfcCrewResource::PredefinedType() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } return ::Ifc4::IfcCrewResourceTypeEnum::FromString(get_attribute_value(10)); }
|
|
void Ifc4::IfcCrewResource::setPredefinedType(const std::optional< ::Ifc4::IfcCrewResourceTypeEnum::Value >& v) { if (v) {set_attribute_value(10, EnumerationReference(&::Ifc4::IfcCrewResourceTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(10);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCrewResource::Class() { return *((IfcParse::entity*)IFC4_types[225]); }
|
|
void Ifc4::IfcCrewResource::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< std::string > v7_LongDescription, ::Ifc4::IfcResourceTime v8_Usage, std::optional< std::vector< ::Ifc4::IfcAppliedValue > > v9_BaseCosts, ::Ifc4::IfcPhysicalQuantity v10_BaseQuantity, std::optional< ::Ifc4::IfcCrewResourceTypeEnum::Value > v11_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_LongDescription) {set_attribute_value(6, (*v7_LongDescription)); }set_attribute_value(7, (v8_Usage)); if (v9_BaseCosts) {set_attribute_value(8, cast_vector<express::Base>(*v9_BaseCosts)); }set_attribute_value(9, (v10_BaseQuantity)); if (v11_PredefinedType) {set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcCrewResourceTypeEnum::Class(),(size_t)*v11_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcCrewResourceType
|
|
::Ifc4::IfcCrewResourceTypeEnum::Value Ifc4::IfcCrewResourceType::PredefinedType() const { return ::Ifc4::IfcCrewResourceTypeEnum::FromString(get_attribute_value(11)); }
|
|
void Ifc4::IfcCrewResourceType::setPredefinedType(const ::Ifc4::IfcCrewResourceTypeEnum::Value& v) { set_attribute_value(11, EnumerationReference(&::Ifc4::IfcCrewResourceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(11); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCrewResourceType::Class() { return *((IfcParse::entity*)IFC4_types[226]); }
|
|
void Ifc4::IfcCrewResourceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::string > v7_Identification, std::optional< std::string > v8_LongDescription, std::optional< std::string > v9_ResourceType, std::optional< std::vector< ::Ifc4::IfcAppliedValue > > v10_BaseCosts, ::Ifc4::IfcPhysicalQuantity v11_BaseQuantity, ::Ifc4::IfcCrewResourceTypeEnum::Value v12_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_Identification) {set_attribute_value(6, (*v7_Identification)); } if (v8_LongDescription) {set_attribute_value(7, (*v8_LongDescription)); } if (v9_ResourceType) {set_attribute_value(8, (*v9_ResourceType)); } if (v10_BaseCosts) {set_attribute_value(9, cast_vector<express::Base>(*v10_BaseCosts)); }set_attribute_value(10, (v11_BaseQuantity));set_attribute_value(11, (EnumerationReference(&::Ifc4::IfcCrewResourceTypeEnum::Class(),(size_t)v12_PredefinedType))); }
|
|
|
|
// Function implementations for IfcCsgPrimitive3D
|
|
::Ifc4::IfcAxis2Placement3D Ifc4::IfcCsgPrimitive3D::Position() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcAxis2Placement3D>(); }
|
|
void Ifc4::IfcCsgPrimitive3D::setPosition(const ::Ifc4::IfcAxis2Placement3D& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCsgPrimitive3D::Class() { return *((IfcParse::entity*)IFC4_types[228]); }
|
|
void Ifc4::IfcCsgPrimitive3D::initialize(::Ifc4::IfcAxis2Placement3D v1_Position) { set_attribute_value(0, (v1_Position)); }
|
|
|
|
// Function implementations for IfcCsgSolid
|
|
::Ifc4::IfcCsgSelect Ifc4::IfcCsgSolid::TreeRootExpression() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcCsgSelect>(); }
|
|
void Ifc4::IfcCsgSolid::setTreeRootExpression(const ::Ifc4::IfcCsgSelect& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCsgSolid::Class() { return *((IfcParse::entity*)IFC4_types[230]); }
|
|
void Ifc4::IfcCsgSolid::initialize(::Ifc4::IfcCsgSelect v1_TreeRootExpression) { set_attribute_value(0, (v1_TreeRootExpression)); }
|
|
|
|
// Function implementations for IfcCurrencyRelationship
|
|
::Ifc4::IfcMonetaryUnit Ifc4::IfcCurrencyRelationship::RelatingMonetaryUnit() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcMonetaryUnit>(); }
|
|
void Ifc4::IfcCurrencyRelationship::setRelatingMonetaryUnit(const ::Ifc4::IfcMonetaryUnit& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcMonetaryUnit Ifc4::IfcCurrencyRelationship::RelatedMonetaryUnit() const { return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcMonetaryUnit>(); }
|
|
void Ifc4::IfcCurrencyRelationship::setRelatedMonetaryUnit(const ::Ifc4::IfcMonetaryUnit& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
double Ifc4::IfcCurrencyRelationship::ExchangeRate() const { double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcCurrencyRelationship::setExchangeRate(const double& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
std::optional< std::string > Ifc4::IfcCurrencyRelationship::RateDateTime() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcCurrencyRelationship::setRateDateTime(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
::Ifc4::IfcLibraryInformation Ifc4::IfcCurrencyRelationship::RateSource() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcLibraryInformation{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcLibraryInformation>(); }
|
|
void Ifc4::IfcCurrencyRelationship::setRateSource(const ::Ifc4::IfcLibraryInformation& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCurrencyRelationship::Class() { return *((IfcParse::entity*)IFC4_types[232]); }
|
|
void Ifc4::IfcCurrencyRelationship::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcMonetaryUnit v3_RelatingMonetaryUnit, ::Ifc4::IfcMonetaryUnit v4_RelatedMonetaryUnit, double v5_ExchangeRate, std::optional< std::string > v6_RateDateTime, ::Ifc4::IfcLibraryInformation v7_RateSource) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_RelatingMonetaryUnit));set_attribute_value(3, (v4_RelatedMonetaryUnit));set_attribute_value(4, (v5_ExchangeRate)); if (v6_RateDateTime) {set_attribute_value(5, (*v6_RateDateTime)); }set_attribute_value(6, (v7_RateSource)); }
|
|
|
|
// Function implementations for IfcCurtainWall
|
|
std::optional< ::Ifc4::IfcCurtainWallTypeEnum::Value > Ifc4::IfcCurtainWall::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcCurtainWallTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcCurtainWall::setPredefinedType(const std::optional< ::Ifc4::IfcCurtainWallTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcCurtainWallTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCurtainWall::Class() { return *((IfcParse::entity*)IFC4_types[233]); }
|
|
void Ifc4::IfcCurtainWall::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcCurtainWallTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcCurtainWallTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcCurtainWallType
|
|
::Ifc4::IfcCurtainWallTypeEnum::Value Ifc4::IfcCurtainWallType::PredefinedType() const { return ::Ifc4::IfcCurtainWallTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcCurtainWallType::setPredefinedType(const ::Ifc4::IfcCurtainWallTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcCurtainWallTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCurtainWallType::Class() { return *((IfcParse::entity*)IFC4_types[234]); }
|
|
void Ifc4::IfcCurtainWallType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcCurtainWallTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcCurtainWallTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcCurve
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCurve::Class() { return *((IfcParse::entity*)IFC4_types[237]); }
|
|
void Ifc4::IfcCurve::initialize() { }
|
|
|
|
// Function implementations for IfcCurveBoundedPlane
|
|
::Ifc4::IfcPlane Ifc4::IfcCurveBoundedPlane::BasisSurface() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcPlane>(); }
|
|
void Ifc4::IfcCurveBoundedPlane::setBasisSurface(const ::Ifc4::IfcPlane& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcCurve Ifc4::IfcCurveBoundedPlane::OuterBoundary() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcCurve>(); }
|
|
void Ifc4::IfcCurveBoundedPlane::setOuterBoundary(const ::Ifc4::IfcCurve& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
std::vector< ::Ifc4::IfcCurve > Ifc4::IfcCurveBoundedPlane::InnerBoundaries() const { std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcCurve>(es); }
|
|
void Ifc4::IfcCurveBoundedPlane::setInnerBoundaries(const std::vector< ::Ifc4::IfcCurve >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCurveBoundedPlane::Class() { return *((IfcParse::entity*)IFC4_types[238]); }
|
|
void Ifc4::IfcCurveBoundedPlane::initialize(::Ifc4::IfcPlane v1_BasisSurface, ::Ifc4::IfcCurve v2_OuterBoundary, std::vector< ::Ifc4::IfcCurve > v3_InnerBoundaries) { set_attribute_value(0, (v1_BasisSurface));set_attribute_value(1, (v2_OuterBoundary));set_attribute_value(2, cast_vector<express::Base>(v3_InnerBoundaries)); }
|
|
|
|
// Function implementations for IfcCurveBoundedSurface
|
|
::Ifc4::IfcSurface Ifc4::IfcCurveBoundedSurface::BasisSurface() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcSurface>(); }
|
|
void Ifc4::IfcCurveBoundedSurface::setBasisSurface(const ::Ifc4::IfcSurface& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::vector< ::Ifc4::IfcBoundaryCurve > Ifc4::IfcCurveBoundedSurface::Boundaries() const { std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcBoundaryCurve>(es); }
|
|
void Ifc4::IfcCurveBoundedSurface::setBoundaries(const std::vector< ::Ifc4::IfcBoundaryCurve >& v) { set_attribute_value(1, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(1); }
|
|
bool Ifc4::IfcCurveBoundedSurface::ImplicitOuter() const { bool v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcCurveBoundedSurface::setImplicitOuter(const bool& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCurveBoundedSurface::Class() { return *((IfcParse::entity*)IFC4_types[239]); }
|
|
void Ifc4::IfcCurveBoundedSurface::initialize(::Ifc4::IfcSurface v1_BasisSurface, std::vector< ::Ifc4::IfcBoundaryCurve > v2_Boundaries, bool v3_ImplicitOuter) { set_attribute_value(0, (v1_BasisSurface));set_attribute_value(1, cast_vector<express::Base>(v2_Boundaries));set_attribute_value(2, (v3_ImplicitOuter)); }
|
|
|
|
// Function implementations for IfcCurveStyle
|
|
::Ifc4::IfcCurveFontOrScaledCurveFontSelect Ifc4::IfcCurveStyle::CurveFont() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcCurveFontOrScaledCurveFontSelect{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcCurveFontOrScaledCurveFontSelect>(); }
|
|
void Ifc4::IfcCurveStyle::setCurveFont(const ::Ifc4::IfcCurveFontOrScaledCurveFontSelect& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcSizeSelect Ifc4::IfcCurveStyle::CurveWidth() const { if(get_attribute_value(2).isNull()) { return ::Ifc4::IfcSizeSelect{}; } return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcSizeSelect>(); }
|
|
void Ifc4::IfcCurveStyle::setCurveWidth(const ::Ifc4::IfcSizeSelect& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcColour Ifc4::IfcCurveStyle::CurveColour() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcColour{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcColour>(); }
|
|
void Ifc4::IfcCurveStyle::setCurveColour(const ::Ifc4::IfcColour& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< bool > Ifc4::IfcCurveStyle::ModelOrDraughting() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } bool v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcCurveStyle::setModelOrDraughting(const std::optional< bool >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCurveStyle::Class() { return *((IfcParse::entity*)IFC4_types[244]); }
|
|
void Ifc4::IfcCurveStyle::initialize(std::optional< std::string > v1_Name, ::Ifc4::IfcCurveFontOrScaledCurveFontSelect v2_CurveFont, ::Ifc4::IfcSizeSelect v3_CurveWidth, ::Ifc4::IfcColour v4_CurveColour, std::optional< bool > v5_ModelOrDraughting) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (v2_CurveFont));set_attribute_value(2, (v3_CurveWidth));set_attribute_value(3, (v4_CurveColour)); if (v5_ModelOrDraughting) {set_attribute_value(4, (*v5_ModelOrDraughting)); } }
|
|
|
|
// Function implementations for IfcCurveStyleFont
|
|
std::optional< std::string > Ifc4::IfcCurveStyleFont::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcCurveStyleFont::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::vector< ::Ifc4::IfcCurveStyleFontPattern > Ifc4::IfcCurveStyleFont::PatternList() const { std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcCurveStyleFontPattern>(es); }
|
|
void Ifc4::IfcCurveStyleFont::setPatternList(const std::vector< ::Ifc4::IfcCurveStyleFontPattern >& v) { set_attribute_value(1, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCurveStyleFont::Class() { return *((IfcParse::entity*)IFC4_types[245]); }
|
|
void Ifc4::IfcCurveStyleFont::initialize(std::optional< std::string > v1_Name, std::vector< ::Ifc4::IfcCurveStyleFontPattern > v2_PatternList) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, cast_vector<express::Base>(v2_PatternList)); }
|
|
|
|
// Function implementations for IfcCurveStyleFontAndScaling
|
|
std::optional< std::string > Ifc4::IfcCurveStyleFontAndScaling::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcCurveStyleFontAndScaling::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
::Ifc4::IfcCurveStyleFontSelect Ifc4::IfcCurveStyleFontAndScaling::CurveFont() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcCurveStyleFontSelect>(); }
|
|
void Ifc4::IfcCurveStyleFontAndScaling::setCurveFont(const ::Ifc4::IfcCurveStyleFontSelect& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
double Ifc4::IfcCurveStyleFontAndScaling::CurveFontScaling() const { double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcCurveStyleFontAndScaling::setCurveFontScaling(const double& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCurveStyleFontAndScaling::Class() { return *((IfcParse::entity*)IFC4_types[246]); }
|
|
void Ifc4::IfcCurveStyleFontAndScaling::initialize(std::optional< std::string > v1_Name, ::Ifc4::IfcCurveStyleFontSelect v2_CurveFont, double v3_CurveFontScaling) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (v2_CurveFont));set_attribute_value(2, (v3_CurveFontScaling)); }
|
|
|
|
// Function implementations for IfcCurveStyleFontPattern
|
|
double Ifc4::IfcCurveStyleFontPattern::VisibleSegmentLength() const { double v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcCurveStyleFontPattern::setVisibleSegmentLength(const double& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
double Ifc4::IfcCurveStyleFontPattern::InvisibleSegmentLength() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcCurveStyleFontPattern::setInvisibleSegmentLength(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCurveStyleFontPattern::Class() { return *((IfcParse::entity*)IFC4_types[247]); }
|
|
void Ifc4::IfcCurveStyleFontPattern::initialize(double v1_VisibleSegmentLength, double v2_InvisibleSegmentLength) { set_attribute_value(0, (v1_VisibleSegmentLength));set_attribute_value(1, (v2_InvisibleSegmentLength)); }
|
|
|
|
// Function implementations for IfcCylindricalSurface
|
|
double Ifc4::IfcCylindricalSurface::Radius() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcCylindricalSurface::setRadius(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcCylindricalSurface::Class() { return *((IfcParse::entity*)IFC4_types[249]); }
|
|
void Ifc4::IfcCylindricalSurface::initialize(::Ifc4::IfcAxis2Placement3D v1_Position, double v2_Radius) { set_attribute_value(0, (v1_Position));set_attribute_value(1, (v2_Radius)); }
|
|
|
|
// Function implementations for IfcDamper
|
|
std::optional< ::Ifc4::IfcDamperTypeEnum::Value > Ifc4::IfcDamper::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcDamperTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcDamper::setPredefinedType(const std::optional< ::Ifc4::IfcDamperTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcDamperTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDamper::Class() { return *((IfcParse::entity*)IFC4_types[250]); }
|
|
void Ifc4::IfcDamper::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcDamperTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcDamperTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcDamperType
|
|
::Ifc4::IfcDamperTypeEnum::Value Ifc4::IfcDamperType::PredefinedType() const { return ::Ifc4::IfcDamperTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcDamperType::setPredefinedType(const ::Ifc4::IfcDamperTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcDamperTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDamperType::Class() { return *((IfcParse::entity*)IFC4_types[251]); }
|
|
void Ifc4::IfcDamperType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcDamperTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcDamperTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcDerivedProfileDef
|
|
::Ifc4::IfcProfileDef Ifc4::IfcDerivedProfileDef::ParentProfile() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcProfileDef>(); }
|
|
void Ifc4::IfcDerivedProfileDef::setParentProfile(const ::Ifc4::IfcProfileDef& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcCartesianTransformationOperator2D Ifc4::IfcDerivedProfileDef::Operator() const { return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcCartesianTransformationOperator2D>(); }
|
|
void Ifc4::IfcDerivedProfileDef::setOperator(const ::Ifc4::IfcCartesianTransformationOperator2D& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< std::string > Ifc4::IfcDerivedProfileDef::Label() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcDerivedProfileDef::setLabel(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDerivedProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[260]); }
|
|
void Ifc4::IfcDerivedProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcProfileDef v3_ParentProfile, ::Ifc4::IfcCartesianTransformationOperator2D v4_Operator, std::optional< std::string > v5_Label) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_ParentProfile));set_attribute_value(3, (v4_Operator)); if (v5_Label) {set_attribute_value(4, (*v5_Label)); } }
|
|
|
|
// Function implementations for IfcDerivedUnit
|
|
std::vector< ::Ifc4::IfcDerivedUnitElement > Ifc4::IfcDerivedUnit::Elements() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcDerivedUnitElement>(es); }
|
|
void Ifc4::IfcDerivedUnit::setElements(const std::vector< ::Ifc4::IfcDerivedUnitElement >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcDerivedUnitEnum::Value Ifc4::IfcDerivedUnit::UnitType() const { return ::Ifc4::IfcDerivedUnitEnum::FromString(get_attribute_value(1)); }
|
|
void Ifc4::IfcDerivedUnit::setUnitType(const ::Ifc4::IfcDerivedUnitEnum::Value& v) { set_attribute_value(1, EnumerationReference(&::Ifc4::IfcDerivedUnitEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(1); }
|
|
std::optional< std::string > Ifc4::IfcDerivedUnit::UserDefinedType() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcDerivedUnit::setUserDefinedType(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDerivedUnit::Class() { return *((IfcParse::entity*)IFC4_types[261]); }
|
|
void Ifc4::IfcDerivedUnit::initialize(std::vector< ::Ifc4::IfcDerivedUnitElement > v1_Elements, ::Ifc4::IfcDerivedUnitEnum::Value v2_UnitType, std::optional< std::string > v3_UserDefinedType) { set_attribute_value(0, cast_vector<express::Base>(v1_Elements));set_attribute_value(1, (EnumerationReference(&::Ifc4::IfcDerivedUnitEnum::Class(),(size_t)v2_UnitType))); if (v3_UserDefinedType) {set_attribute_value(2, (*v3_UserDefinedType)); } }
|
|
|
|
// Function implementations for IfcDerivedUnitElement
|
|
::Ifc4::IfcNamedUnit Ifc4::IfcDerivedUnitElement::Unit() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcNamedUnit>(); }
|
|
void Ifc4::IfcDerivedUnitElement::setUnit(const ::Ifc4::IfcNamedUnit& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
int Ifc4::IfcDerivedUnitElement::Exponent() const { int v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcDerivedUnitElement::setExponent(const int& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDerivedUnitElement::Class() { return *((IfcParse::entity*)IFC4_types[262]); }
|
|
void Ifc4::IfcDerivedUnitElement::initialize(::Ifc4::IfcNamedUnit v1_Unit, int v2_Exponent) { set_attribute_value(0, (v1_Unit));set_attribute_value(1, (v2_Exponent)); }
|
|
|
|
// Function implementations for IfcDimensionalExponents
|
|
int Ifc4::IfcDimensionalExponents::LengthExponent() const { int v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcDimensionalExponents::setLengthExponent(const int& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
int Ifc4::IfcDimensionalExponents::MassExponent() const { int v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcDimensionalExponents::setMassExponent(const int& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
int Ifc4::IfcDimensionalExponents::TimeExponent() const { int v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcDimensionalExponents::setTimeExponent(const int& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
int Ifc4::IfcDimensionalExponents::ElectricCurrentExponent() const { int v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcDimensionalExponents::setElectricCurrentExponent(const int& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
int Ifc4::IfcDimensionalExponents::ThermodynamicTemperatureExponent() const { int v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcDimensionalExponents::setThermodynamicTemperatureExponent(const int& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
int Ifc4::IfcDimensionalExponents::AmountOfSubstanceExponent() const { int v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcDimensionalExponents::setAmountOfSubstanceExponent(const int& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
int Ifc4::IfcDimensionalExponents::LuminousIntensityExponent() const { int v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcDimensionalExponents::setLuminousIntensityExponent(const int& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDimensionalExponents::Class() { return *((IfcParse::entity*)IFC4_types[265]); }
|
|
void Ifc4::IfcDimensionalExponents::initialize(int v1_LengthExponent, int v2_MassExponent, int v3_TimeExponent, int v4_ElectricCurrentExponent, int v5_ThermodynamicTemperatureExponent, int v6_AmountOfSubstanceExponent, int v7_LuminousIntensityExponent) { 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)); }
|
|
|
|
// Function implementations for IfcDirection
|
|
std::vector< double > /*[2:3]*/ Ifc4::IfcDirection::DirectionRatios() const { std::vector< double > /*[2:3]*/ v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcDirection::setDirectionRatios(const std::vector< double > /*[2:3]*/& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDirection::Class() { return *((IfcParse::entity*)IFC4_types[267]); }
|
|
void Ifc4::IfcDirection::initialize(std::vector< double > /*[2:3]*/ v1_DirectionRatios) { set_attribute_value(0, (v1_DirectionRatios)); }
|
|
|
|
// Function implementations for IfcDiscreteAccessory
|
|
std::optional< ::Ifc4::IfcDiscreteAccessoryTypeEnum::Value > Ifc4::IfcDiscreteAccessory::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcDiscreteAccessoryTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcDiscreteAccessory::setPredefinedType(const std::optional< ::Ifc4::IfcDiscreteAccessoryTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcDiscreteAccessoryTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDiscreteAccessory::Class() { return *((IfcParse::entity*)IFC4_types[269]); }
|
|
void Ifc4::IfcDiscreteAccessory::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcDiscreteAccessoryTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcDiscreteAccessoryTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcDiscreteAccessoryType
|
|
::Ifc4::IfcDiscreteAccessoryTypeEnum::Value Ifc4::IfcDiscreteAccessoryType::PredefinedType() const { return ::Ifc4::IfcDiscreteAccessoryTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcDiscreteAccessoryType::setPredefinedType(const ::Ifc4::IfcDiscreteAccessoryTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcDiscreteAccessoryTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDiscreteAccessoryType::Class() { return *((IfcParse::entity*)IFC4_types[270]); }
|
|
void Ifc4::IfcDiscreteAccessoryType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcDiscreteAccessoryTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcDiscreteAccessoryTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcDistributionChamberElement
|
|
std::optional< ::Ifc4::IfcDistributionChamberElementTypeEnum::Value > Ifc4::IfcDistributionChamberElement::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcDistributionChamberElementTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcDistributionChamberElement::setPredefinedType(const std::optional< ::Ifc4::IfcDistributionChamberElementTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcDistributionChamberElementTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDistributionChamberElement::Class() { return *((IfcParse::entity*)IFC4_types[272]); }
|
|
void Ifc4::IfcDistributionChamberElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcDistributionChamberElementTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcDistributionChamberElementTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcDistributionChamberElementType
|
|
::Ifc4::IfcDistributionChamberElementTypeEnum::Value Ifc4::IfcDistributionChamberElementType::PredefinedType() const { return ::Ifc4::IfcDistributionChamberElementTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcDistributionChamberElementType::setPredefinedType(const ::Ifc4::IfcDistributionChamberElementTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcDistributionChamberElementTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDistributionChamberElementType::Class() { return *((IfcParse::entity*)IFC4_types[273]); }
|
|
void Ifc4::IfcDistributionChamberElementType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcDistributionChamberElementTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcDistributionChamberElementTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcDistributionCircuit
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDistributionCircuit::Class() { return *((IfcParse::entity*)IFC4_types[275]); }
|
|
void Ifc4::IfcDistributionCircuit::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_LongName, std::optional< ::Ifc4::IfcDistributionSystemEnum::Value > v7_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_PredefinedType) {set_attribute_value(6, (EnumerationReference(&::Ifc4::IfcDistributionSystemEnum::Class(),(size_t)*v7_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcDistributionControlElement
|
|
|
|
std::vector<::Ifc4::IfcRelFlowControlElements> Ifc4::IfcDistributionControlElement::AssignedToFlowElement() const { return cast_vector<IfcRelFlowControlElements>(file()->getInverse(data()->id(), IFC4_types[834], 4)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcDistributionControlElement::Class() { return *((IfcParse::entity*)IFC4_types[276]); }
|
|
void Ifc4::IfcDistributionControlElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcDistributionControlElementType
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDistributionControlElementType::Class() { return *((IfcParse::entity*)IFC4_types[277]); }
|
|
void Ifc4::IfcDistributionControlElementType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcDistributionElement
|
|
|
|
std::vector<::Ifc4::IfcRelConnectsPortToElement> Ifc4::IfcDistributionElement::HasPorts() const { return cast_vector<IfcRelConnectsPortToElement>(file()->getInverse(data()->id(), IFC4_types[818], 5)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcDistributionElement::Class() { return *((IfcParse::entity*)IFC4_types[278]); }
|
|
void Ifc4::IfcDistributionElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcDistributionElementType
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDistributionElementType::Class() { return *((IfcParse::entity*)IFC4_types[279]); }
|
|
void Ifc4::IfcDistributionElementType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcDistributionFlowElement
|
|
|
|
std::vector<::Ifc4::IfcRelFlowControlElements> Ifc4::IfcDistributionFlowElement::HasControlElements() const { return cast_vector<IfcRelFlowControlElements>(file()->getInverse(data()->id(), IFC4_types[834], 5)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcDistributionFlowElement::Class() { return *((IfcParse::entity*)IFC4_types[280]); }
|
|
void Ifc4::IfcDistributionFlowElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcDistributionFlowElementType
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDistributionFlowElementType::Class() { return *((IfcParse::entity*)IFC4_types[281]); }
|
|
void Ifc4::IfcDistributionFlowElementType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcDistributionPort
|
|
std::optional< ::Ifc4::IfcFlowDirectionEnum::Value > Ifc4::IfcDistributionPort::FlowDirection() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } return ::Ifc4::IfcFlowDirectionEnum::FromString(get_attribute_value(7)); }
|
|
void Ifc4::IfcDistributionPort::setFlowDirection(const std::optional< ::Ifc4::IfcFlowDirectionEnum::Value >& v) { if (v) {set_attribute_value(7, EnumerationReference(&::Ifc4::IfcFlowDirectionEnum::Class(), (size_t) *v));} else {unset_attribute_value(7);} }
|
|
std::optional< ::Ifc4::IfcDistributionPortTypeEnum::Value > Ifc4::IfcDistributionPort::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcDistributionPortTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcDistributionPort::setPredefinedType(const std::optional< ::Ifc4::IfcDistributionPortTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcDistributionPortTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
std::optional< ::Ifc4::IfcDistributionSystemEnum::Value > Ifc4::IfcDistributionPort::SystemType() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } return ::Ifc4::IfcDistributionSystemEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcDistributionPort::setSystemType(const std::optional< ::Ifc4::IfcDistributionSystemEnum::Value >& v) { if (v) {set_attribute_value(9, EnumerationReference(&::Ifc4::IfcDistributionSystemEnum::Class(), (size_t) *v));} else {unset_attribute_value(9);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDistributionPort::Class() { return *((IfcParse::entity*)IFC4_types[282]); }
|
|
void Ifc4::IfcDistributionPort::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< ::Ifc4::IfcFlowDirectionEnum::Value > v8_FlowDirection, std::optional< ::Ifc4::IfcDistributionPortTypeEnum::Value > v9_PredefinedType, std::optional< ::Ifc4::IfcDistributionSystemEnum::Value > v10_SystemType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_FlowDirection) {set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcFlowDirectionEnum::Class(),(size_t)*v8_FlowDirection))); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcDistributionPortTypeEnum::Class(),(size_t)*v9_PredefinedType))); } if (v10_SystemType) {set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcDistributionSystemEnum::Class(),(size_t)*v10_SystemType))); } }
|
|
|
|
// Function implementations for IfcDistributionSystem
|
|
std::optional< std::string > Ifc4::IfcDistributionSystem::LongName() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcDistributionSystem::setLongName(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< ::Ifc4::IfcDistributionSystemEnum::Value > Ifc4::IfcDistributionSystem::PredefinedType() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } return ::Ifc4::IfcDistributionSystemEnum::FromString(get_attribute_value(6)); }
|
|
void Ifc4::IfcDistributionSystem::setPredefinedType(const std::optional< ::Ifc4::IfcDistributionSystemEnum::Value >& v) { if (v) {set_attribute_value(6, EnumerationReference(&::Ifc4::IfcDistributionSystemEnum::Class(), (size_t) *v));} else {unset_attribute_value(6);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDistributionSystem::Class() { return *((IfcParse::entity*)IFC4_types[284]); }
|
|
void Ifc4::IfcDistributionSystem::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_LongName, std::optional< ::Ifc4::IfcDistributionSystemEnum::Value > v7_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_PredefinedType) {set_attribute_value(6, (EnumerationReference(&::Ifc4::IfcDistributionSystemEnum::Class(),(size_t)*v7_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcDocumentInformation
|
|
std::string Ifc4::IfcDocumentInformation::Identification() const { std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcDocumentInformation::setIdentification(const std::string& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::string Ifc4::IfcDocumentInformation::Name() const { std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcDocumentInformation::setName(const std::string& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
std::optional< std::string > Ifc4::IfcDocumentInformation::Description() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcDocumentInformation::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< std::string > Ifc4::IfcDocumentInformation::Location() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcDocumentInformation::setLocation(const std::optional< std::string >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< std::string > Ifc4::IfcDocumentInformation::Purpose() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcDocumentInformation::setPurpose(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcDocumentInformation::IntendedUse() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcDocumentInformation::setIntendedUse(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< std::string > Ifc4::IfcDocumentInformation::Scope() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcDocumentInformation::setScope(const std::optional< std::string >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
std::optional< std::string > Ifc4::IfcDocumentInformation::Revision() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::string v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcDocumentInformation::setRevision(const std::optional< std::string >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
::Ifc4::IfcActorSelect Ifc4::IfcDocumentInformation::DocumentOwner() const { if(get_attribute_value(8).isNull()) { return ::Ifc4::IfcActorSelect{}; } return ((express::Base)(get_attribute_value(8))).as<::Ifc4::IfcActorSelect>(); }
|
|
void Ifc4::IfcDocumentInformation::setDocumentOwner(const ::Ifc4::IfcActorSelect& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
std::optional< std::vector< ::Ifc4::IfcActorSelect > > Ifc4::IfcDocumentInformation::Editors() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(9); return cast_vector<::Ifc4::IfcActorSelect>(es); }
|
|
void Ifc4::IfcDocumentInformation::setEditors(const std::optional< std::vector< ::Ifc4::IfcActorSelect > >& v) { if (v) {set_attribute_value(9, cast_vector<express::Base>(*v));} else {unset_attribute_value(9);} }
|
|
std::optional< std::string > Ifc4::IfcDocumentInformation::CreationTime() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } std::string v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcDocumentInformation::setCreationTime(const std::optional< std::string >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::optional< std::string > Ifc4::IfcDocumentInformation::LastRevisionTime() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } std::string v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcDocumentInformation::setLastRevisionTime(const std::optional< std::string >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
std::optional< std::string > Ifc4::IfcDocumentInformation::ElectronicFormat() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } std::string v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcDocumentInformation::setElectronicFormat(const std::optional< std::string >& v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
|
|
std::optional< std::string > Ifc4::IfcDocumentInformation::ValidFrom() const { if(get_attribute_value(13).isNull()) { return std::nullopt; } std::string v = get_attribute_value(13); return v; }
|
|
void Ifc4::IfcDocumentInformation::setValidFrom(const std::optional< std::string >& v) { if (v) {set_attribute_value(13, *v);} else {unset_attribute_value(13);} }
|
|
std::optional< std::string > Ifc4::IfcDocumentInformation::ValidUntil() const { if(get_attribute_value(14).isNull()) { return std::nullopt; } std::string v = get_attribute_value(14); return v; }
|
|
void Ifc4::IfcDocumentInformation::setValidUntil(const std::optional< std::string >& v) { if (v) {set_attribute_value(14, *v);} else {unset_attribute_value(14);} }
|
|
std::optional< ::Ifc4::IfcDocumentConfidentialityEnum::Value > Ifc4::IfcDocumentInformation::Confidentiality() const { if(get_attribute_value(15).isNull()) { return std::nullopt; } return ::Ifc4::IfcDocumentConfidentialityEnum::FromString(get_attribute_value(15)); }
|
|
void Ifc4::IfcDocumentInformation::setConfidentiality(const std::optional< ::Ifc4::IfcDocumentConfidentialityEnum::Value >& v) { if (v) {set_attribute_value(15, EnumerationReference(&::Ifc4::IfcDocumentConfidentialityEnum::Class(), (size_t) *v));} else {unset_attribute_value(15);} }
|
|
std::optional< ::Ifc4::IfcDocumentStatusEnum::Value > Ifc4::IfcDocumentInformation::Status() const { if(get_attribute_value(16).isNull()) { return std::nullopt; } return ::Ifc4::IfcDocumentStatusEnum::FromString(get_attribute_value(16)); }
|
|
void Ifc4::IfcDocumentInformation::setStatus(const std::optional< ::Ifc4::IfcDocumentStatusEnum::Value >& v) { if (v) {set_attribute_value(16, EnumerationReference(&::Ifc4::IfcDocumentStatusEnum::Class(), (size_t) *v));} else {unset_attribute_value(16);} }
|
|
|
|
std::vector<::Ifc4::IfcRelAssociatesDocument> Ifc4::IfcDocumentInformation::DocumentInfoForObjects() const { return cast_vector<IfcRelAssociatesDocument>(file()->getInverse(data()->id(), IFC4_types[810], 5)); }
|
|
std::vector<::Ifc4::IfcDocumentReference> Ifc4::IfcDocumentInformation::HasDocumentReferences() const { return cast_vector<IfcDocumentReference>(file()->getInverse(data()->id(), IFC4_types[289], 4)); }
|
|
std::vector<::Ifc4::IfcDocumentInformationRelationship> Ifc4::IfcDocumentInformation::IsPointedTo() const { return cast_vector<IfcDocumentInformationRelationship>(file()->getInverse(data()->id(), IFC4_types[288], 3)); }
|
|
std::vector<::Ifc4::IfcDocumentInformationRelationship> Ifc4::IfcDocumentInformation::IsPointer() const { return cast_vector<IfcDocumentInformationRelationship>(file()->getInverse(data()->id(), IFC4_types[288], 2)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcDocumentInformation::Class() { return *((IfcParse::entity*)IFC4_types[287]); }
|
|
void Ifc4::IfcDocumentInformation::initialize(std::string v1_Identification, std::string v2_Name, std::optional< std::string > v3_Description, std::optional< std::string > v4_Location, std::optional< std::string > v5_Purpose, std::optional< std::string > v6_IntendedUse, std::optional< std::string > v7_Scope, std::optional< std::string > v8_Revision, ::Ifc4::IfcActorSelect v9_DocumentOwner, std::optional< std::vector< ::Ifc4::IfcActorSelect > > v10_Editors, std::optional< std::string > v11_CreationTime, std::optional< std::string > v12_LastRevisionTime, std::optional< std::string > v13_ElectronicFormat, std::optional< std::string > v14_ValidFrom, std::optional< std::string > v15_ValidUntil, std::optional< ::Ifc4::IfcDocumentConfidentialityEnum::Value > v16_Confidentiality, std::optional< ::Ifc4::IfcDocumentStatusEnum::Value > v17_Status) { set_attribute_value(0, (v1_Identification));set_attribute_value(1, (v2_Name)); if (v3_Description) {set_attribute_value(2, (*v3_Description)); } if (v4_Location) {set_attribute_value(3, (*v4_Location)); } 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)); if (v10_Editors) {set_attribute_value(9, cast_vector<express::Base>(*v10_Editors)); } if (v11_CreationTime) {set_attribute_value(10, (*v11_CreationTime)); } if (v12_LastRevisionTime) {set_attribute_value(11, (*v12_LastRevisionTime)); } if (v13_ElectronicFormat) {set_attribute_value(12, (*v13_ElectronicFormat)); } if (v14_ValidFrom) {set_attribute_value(13, (*v14_ValidFrom)); } if (v15_ValidUntil) {set_attribute_value(14, (*v15_ValidUntil)); } if (v16_Confidentiality) {set_attribute_value(15, (EnumerationReference(&::Ifc4::IfcDocumentConfidentialityEnum::Class(),(size_t)*v16_Confidentiality))); } if (v17_Status) {set_attribute_value(16, (EnumerationReference(&::Ifc4::IfcDocumentStatusEnum::Class(),(size_t)*v17_Status))); } }
|
|
|
|
// Function implementations for IfcDocumentInformationRelationship
|
|
::Ifc4::IfcDocumentInformation Ifc4::IfcDocumentInformationRelationship::RelatingDocument() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcDocumentInformation>(); }
|
|
void Ifc4::IfcDocumentInformationRelationship::setRelatingDocument(const ::Ifc4::IfcDocumentInformation& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
std::vector< ::Ifc4::IfcDocumentInformation > Ifc4::IfcDocumentInformationRelationship::RelatedDocuments() const { std::vector<express::Base> es = get_attribute_value(3); return cast_vector<::Ifc4::IfcDocumentInformation>(es); }
|
|
void Ifc4::IfcDocumentInformationRelationship::setRelatedDocuments(const std::vector< ::Ifc4::IfcDocumentInformation >& v) { set_attribute_value(3, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< std::string > Ifc4::IfcDocumentInformationRelationship::RelationshipType() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcDocumentInformationRelationship::setRelationshipType(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDocumentInformationRelationship::Class() { return *((IfcParse::entity*)IFC4_types[288]); }
|
|
void Ifc4::IfcDocumentInformationRelationship::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcDocumentInformation v3_RelatingDocument, std::vector< ::Ifc4::IfcDocumentInformation > v4_RelatedDocuments, std::optional< std::string > v5_RelationshipType) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_RelatingDocument));set_attribute_value(3, cast_vector<express::Base>(v4_RelatedDocuments)); if (v5_RelationshipType) {set_attribute_value(4, (*v5_RelationshipType)); } }
|
|
|
|
// Function implementations for IfcDocumentReference
|
|
std::optional< std::string > Ifc4::IfcDocumentReference::Description() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcDocumentReference::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
::Ifc4::IfcDocumentInformation Ifc4::IfcDocumentReference::ReferencedDocument() const { if(get_attribute_value(4).isNull()) { return ::Ifc4::IfcDocumentInformation{}; } return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcDocumentInformation>(); }
|
|
void Ifc4::IfcDocumentReference::setReferencedDocument(const ::Ifc4::IfcDocumentInformation& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
|
|
std::vector<::Ifc4::IfcRelAssociatesDocument> Ifc4::IfcDocumentReference::DocumentRefForObjects() const { return cast_vector<IfcRelAssociatesDocument>(file()->getInverse(data()->id(), IFC4_types[810], 5)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcDocumentReference::Class() { return *((IfcParse::entity*)IFC4_types[289]); }
|
|
void Ifc4::IfcDocumentReference::initialize(std::optional< std::string > v1_Location, std::optional< std::string > v2_Identification, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcDocumentInformation v5_ReferencedDocument) { if (v1_Location) {set_attribute_value(0, (*v1_Location)); } if (v2_Identification) {set_attribute_value(1, (*v2_Identification)); } if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_ReferencedDocument)); }
|
|
|
|
// Function implementations for IfcDoor
|
|
std::optional< double > Ifc4::IfcDoor::OverallHeight() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } double v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcDoor::setOverallHeight(const std::optional< double >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
std::optional< double > Ifc4::IfcDoor::OverallWidth() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } double v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcDoor::setOverallWidth(const std::optional< double >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
std::optional< ::Ifc4::IfcDoorTypeEnum::Value > Ifc4::IfcDoor::PredefinedType() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } return ::Ifc4::IfcDoorTypeEnum::FromString(get_attribute_value(10)); }
|
|
void Ifc4::IfcDoor::setPredefinedType(const std::optional< ::Ifc4::IfcDoorTypeEnum::Value >& v) { if (v) {set_attribute_value(10, EnumerationReference(&::Ifc4::IfcDoorTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(10);} }
|
|
std::optional< ::Ifc4::IfcDoorTypeOperationEnum::Value > Ifc4::IfcDoor::OperationType() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } return ::Ifc4::IfcDoorTypeOperationEnum::FromString(get_attribute_value(11)); }
|
|
void Ifc4::IfcDoor::setOperationType(const std::optional< ::Ifc4::IfcDoorTypeOperationEnum::Value >& v) { if (v) {set_attribute_value(11, EnumerationReference(&::Ifc4::IfcDoorTypeOperationEnum::Class(), (size_t) *v));} else {unset_attribute_value(11);} }
|
|
std::optional< std::string > Ifc4::IfcDoor::UserDefinedOperationType() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } std::string v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcDoor::setUserDefinedOperationType(const std::optional< std::string >& v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDoor::Class() { return *((IfcParse::entity*)IFC4_types[292]); }
|
|
void Ifc4::IfcDoor::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< double > v9_OverallHeight, std::optional< double > v10_OverallWidth, std::optional< ::Ifc4::IfcDoorTypeEnum::Value > v11_PredefinedType, std::optional< ::Ifc4::IfcDoorTypeOperationEnum::Value > v12_OperationType, std::optional< std::string > v13_UserDefinedOperationType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); 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)); } if (v11_PredefinedType) {set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcDoorTypeEnum::Class(),(size_t)*v11_PredefinedType))); } if (v12_OperationType) {set_attribute_value(11, (EnumerationReference(&::Ifc4::IfcDoorTypeOperationEnum::Class(),(size_t)*v12_OperationType))); } if (v13_UserDefinedOperationType) {set_attribute_value(12, (*v13_UserDefinedOperationType)); } }
|
|
|
|
// Function implementations for IfcDoorLiningProperties
|
|
std::optional< double > Ifc4::IfcDoorLiningProperties::LiningDepth() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcDoorLiningProperties::setLiningDepth(const std::optional< double >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< double > Ifc4::IfcDoorLiningProperties::LiningThickness() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcDoorLiningProperties::setLiningThickness(const std::optional< double >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< double > Ifc4::IfcDoorLiningProperties::ThresholdDepth() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcDoorLiningProperties::setThresholdDepth(const std::optional< double >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
std::optional< double > Ifc4::IfcDoorLiningProperties::ThresholdThickness() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcDoorLiningProperties::setThresholdThickness(const std::optional< double >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< double > Ifc4::IfcDoorLiningProperties::TransomThickness() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } double v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcDoorLiningProperties::setTransomThickness(const std::optional< double >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
std::optional< double > Ifc4::IfcDoorLiningProperties::TransomOffset() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } double v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcDoorLiningProperties::setTransomOffset(const std::optional< double >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
std::optional< double > Ifc4::IfcDoorLiningProperties::LiningOffset() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } double v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcDoorLiningProperties::setLiningOffset(const std::optional< double >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::optional< double > Ifc4::IfcDoorLiningProperties::ThresholdOffset() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } double v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcDoorLiningProperties::setThresholdOffset(const std::optional< double >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
std::optional< double > Ifc4::IfcDoorLiningProperties::CasingThickness() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } double v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcDoorLiningProperties::setCasingThickness(const std::optional< double >& v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
|
|
std::optional< double > Ifc4::IfcDoorLiningProperties::CasingDepth() const { if(get_attribute_value(13).isNull()) { return std::nullopt; } double v = get_attribute_value(13); return v; }
|
|
void Ifc4::IfcDoorLiningProperties::setCasingDepth(const std::optional< double >& v) { if (v) {set_attribute_value(13, *v);} else {unset_attribute_value(13);} }
|
|
::Ifc4::IfcShapeAspect Ifc4::IfcDoorLiningProperties::ShapeAspectStyle() const { if(get_attribute_value(14).isNull()) { return ::Ifc4::IfcShapeAspect{}; } return ((express::Base)(get_attribute_value(14))).as<::Ifc4::IfcShapeAspect>(); }
|
|
void Ifc4::IfcDoorLiningProperties::setShapeAspectStyle(const ::Ifc4::IfcShapeAspect& v) { set_attribute_value(14, v);if constexpr (false)unset_attribute_value(14); }
|
|
std::optional< double > Ifc4::IfcDoorLiningProperties::LiningToPanelOffsetX() const { if(get_attribute_value(15).isNull()) { return std::nullopt; } double v = get_attribute_value(15); return v; }
|
|
void Ifc4::IfcDoorLiningProperties::setLiningToPanelOffsetX(const std::optional< double >& v) { if (v) {set_attribute_value(15, *v);} else {unset_attribute_value(15);} }
|
|
std::optional< double > Ifc4::IfcDoorLiningProperties::LiningToPanelOffsetY() const { if(get_attribute_value(16).isNull()) { return std::nullopt; } double v = get_attribute_value(16); return v; }
|
|
void Ifc4::IfcDoorLiningProperties::setLiningToPanelOffsetY(const std::optional< double >& v) { if (v) {set_attribute_value(16, *v);} else {unset_attribute_value(16);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDoorLiningProperties::Class() { return *((IfcParse::entity*)IFC4_types[293]); }
|
|
void Ifc4::IfcDoorLiningProperties::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< double > v5_LiningDepth, std::optional< double > v6_LiningThickness, std::optional< double > v7_ThresholdDepth, std::optional< double > v8_ThresholdThickness, std::optional< double > v9_TransomThickness, std::optional< double > v10_TransomOffset, std::optional< double > v11_LiningOffset, std::optional< double > v12_ThresholdOffset, std::optional< double > v13_CasingThickness, std::optional< double > v14_CasingDepth, ::Ifc4::IfcShapeAspect v15_ShapeAspectStyle, std::optional< double > v16_LiningToPanelOffsetX, std::optional< double > v17_LiningToPanelOffsetY) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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)); if (v16_LiningToPanelOffsetX) {set_attribute_value(15, (*v16_LiningToPanelOffsetX)); } if (v17_LiningToPanelOffsetY) {set_attribute_value(16, (*v17_LiningToPanelOffsetY)); } }
|
|
|
|
// Function implementations for IfcDoorPanelProperties
|
|
std::optional< double > Ifc4::IfcDoorPanelProperties::PanelDepth() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcDoorPanelProperties::setPanelDepth(const std::optional< double >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
::Ifc4::IfcDoorPanelOperationEnum::Value Ifc4::IfcDoorPanelProperties::PanelOperation() const { return ::Ifc4::IfcDoorPanelOperationEnum::FromString(get_attribute_value(5)); }
|
|
void Ifc4::IfcDoorPanelProperties::setPanelOperation(const ::Ifc4::IfcDoorPanelOperationEnum::Value& v) { set_attribute_value(5, EnumerationReference(&::Ifc4::IfcDoorPanelOperationEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(5); }
|
|
std::optional< double > Ifc4::IfcDoorPanelProperties::PanelWidth() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcDoorPanelProperties::setPanelWidth(const std::optional< double >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
::Ifc4::IfcDoorPanelPositionEnum::Value Ifc4::IfcDoorPanelProperties::PanelPosition() const { return ::Ifc4::IfcDoorPanelPositionEnum::FromString(get_attribute_value(7)); }
|
|
void Ifc4::IfcDoorPanelProperties::setPanelPosition(const ::Ifc4::IfcDoorPanelPositionEnum::Value& v) { set_attribute_value(7, EnumerationReference(&::Ifc4::IfcDoorPanelPositionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }
|
|
::Ifc4::IfcShapeAspect Ifc4::IfcDoorPanelProperties::ShapeAspectStyle() const { if(get_attribute_value(8).isNull()) { return ::Ifc4::IfcShapeAspect{}; } return ((express::Base)(get_attribute_value(8))).as<::Ifc4::IfcShapeAspect>(); }
|
|
void Ifc4::IfcDoorPanelProperties::setShapeAspectStyle(const ::Ifc4::IfcShapeAspect& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDoorPanelProperties::Class() { return *((IfcParse::entity*)IFC4_types[296]); }
|
|
void Ifc4::IfcDoorPanelProperties::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< double > v5_PanelDepth, ::Ifc4::IfcDoorPanelOperationEnum::Value v6_PanelOperation, std::optional< double > v7_PanelWidth, ::Ifc4::IfcDoorPanelPositionEnum::Value v8_PanelPosition, ::Ifc4::IfcShapeAspect v9_ShapeAspectStyle) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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(&::Ifc4::IfcDoorPanelOperationEnum::Class(),(size_t)v6_PanelOperation))); if (v7_PanelWidth) {set_attribute_value(6, (*v7_PanelWidth)); }set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcDoorPanelPositionEnum::Class(),(size_t)v8_PanelPosition)));set_attribute_value(8, (v9_ShapeAspectStyle)); }
|
|
|
|
// Function implementations for IfcDoorStandardCase
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDoorStandardCase::Class() { return *((IfcParse::entity*)IFC4_types[297]); }
|
|
void Ifc4::IfcDoorStandardCase::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< double > v9_OverallHeight, std::optional< double > v10_OverallWidth, std::optional< ::Ifc4::IfcDoorTypeEnum::Value > v11_PredefinedType, std::optional< ::Ifc4::IfcDoorTypeOperationEnum::Value > v12_OperationType, std::optional< std::string > v13_UserDefinedOperationType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); 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)); } if (v11_PredefinedType) {set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcDoorTypeEnum::Class(),(size_t)*v11_PredefinedType))); } if (v12_OperationType) {set_attribute_value(11, (EnumerationReference(&::Ifc4::IfcDoorTypeOperationEnum::Class(),(size_t)*v12_OperationType))); } if (v13_UserDefinedOperationType) {set_attribute_value(12, (*v13_UserDefinedOperationType)); } }
|
|
|
|
// Function implementations for IfcDoorStyle
|
|
::Ifc4::IfcDoorStyleOperationEnum::Value Ifc4::IfcDoorStyle::OperationType() const { return ::Ifc4::IfcDoorStyleOperationEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcDoorStyle::setOperationType(const ::Ifc4::IfcDoorStyleOperationEnum::Value& v) { set_attribute_value(8, EnumerationReference(&::Ifc4::IfcDoorStyleOperationEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }
|
|
::Ifc4::IfcDoorStyleConstructionEnum::Value Ifc4::IfcDoorStyle::ConstructionType() const { return ::Ifc4::IfcDoorStyleConstructionEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcDoorStyle::setConstructionType(const ::Ifc4::IfcDoorStyleConstructionEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcDoorStyleConstructionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
bool Ifc4::IfcDoorStyle::ParameterTakesPrecedence() const { bool v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcDoorStyle::setParameterTakesPrecedence(const bool& v) { set_attribute_value(10, v);if constexpr (false)unset_attribute_value(10); }
|
|
bool Ifc4::IfcDoorStyle::Sizeable() const { bool v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcDoorStyle::setSizeable(const bool& v) { set_attribute_value(11, v);if constexpr (false)unset_attribute_value(11); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDoorStyle::Class() { return *((IfcParse::entity*)IFC4_types[298]); }
|
|
void Ifc4::IfcDoorStyle::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, ::Ifc4::IfcDoorStyleOperationEnum::Value v9_OperationType, ::Ifc4::IfcDoorStyleConstructionEnum::Value v10_ConstructionType, bool v11_ParameterTakesPrecedence, bool v12_Sizeable) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcDoorStyleOperationEnum::Class(),(size_t)v9_OperationType)));set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcDoorStyleConstructionEnum::Class(),(size_t)v10_ConstructionType)));set_attribute_value(10, (v11_ParameterTakesPrecedence));set_attribute_value(11, (v12_Sizeable)); }
|
|
|
|
// Function implementations for IfcDoorType
|
|
::Ifc4::IfcDoorTypeEnum::Value Ifc4::IfcDoorType::PredefinedType() const { return ::Ifc4::IfcDoorTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcDoorType::setPredefinedType(const ::Ifc4::IfcDoorTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcDoorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
::Ifc4::IfcDoorTypeOperationEnum::Value Ifc4::IfcDoorType::OperationType() const { return ::Ifc4::IfcDoorTypeOperationEnum::FromString(get_attribute_value(10)); }
|
|
void Ifc4::IfcDoorType::setOperationType(const ::Ifc4::IfcDoorTypeOperationEnum::Value& v) { set_attribute_value(10, EnumerationReference(&::Ifc4::IfcDoorTypeOperationEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(10); }
|
|
std::optional< bool > Ifc4::IfcDoorType::ParameterTakesPrecedence() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } bool v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcDoorType::setParameterTakesPrecedence(const std::optional< bool >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
std::optional< std::string > Ifc4::IfcDoorType::UserDefinedOperationType() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } std::string v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcDoorType::setUserDefinedOperationType(const std::optional< std::string >& v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDoorType::Class() { return *((IfcParse::entity*)IFC4_types[301]); }
|
|
void Ifc4::IfcDoorType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcDoorTypeEnum::Value v10_PredefinedType, ::Ifc4::IfcDoorTypeOperationEnum::Value v11_OperationType, std::optional< bool > v12_ParameterTakesPrecedence, std::optional< std::string > v13_UserDefinedOperationType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcDoorTypeEnum::Class(),(size_t)v10_PredefinedType)));set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcDoorTypeOperationEnum::Class(),(size_t)v11_OperationType))); if (v12_ParameterTakesPrecedence) {set_attribute_value(11, (*v12_ParameterTakesPrecedence)); } if (v13_UserDefinedOperationType) {set_attribute_value(12, (*v13_UserDefinedOperationType)); } }
|
|
|
|
// Function implementations for IfcDraughtingPreDefinedColour
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDraughtingPreDefinedColour::Class() { return *((IfcParse::entity*)IFC4_types[305]); }
|
|
void Ifc4::IfcDraughtingPreDefinedColour::initialize(std::string v1_Name) { set_attribute_value(0, (v1_Name)); }
|
|
|
|
// Function implementations for IfcDraughtingPreDefinedCurveFont
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDraughtingPreDefinedCurveFont::Class() { return *((IfcParse::entity*)IFC4_types[306]); }
|
|
void Ifc4::IfcDraughtingPreDefinedCurveFont::initialize(std::string v1_Name) { set_attribute_value(0, (v1_Name)); }
|
|
|
|
// Function implementations for IfcDuctFitting
|
|
std::optional< ::Ifc4::IfcDuctFittingTypeEnum::Value > Ifc4::IfcDuctFitting::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcDuctFittingTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcDuctFitting::setPredefinedType(const std::optional< ::Ifc4::IfcDuctFittingTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcDuctFittingTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDuctFitting::Class() { return *((IfcParse::entity*)IFC4_types[307]); }
|
|
void Ifc4::IfcDuctFitting::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcDuctFittingTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcDuctFittingTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcDuctFittingType
|
|
::Ifc4::IfcDuctFittingTypeEnum::Value Ifc4::IfcDuctFittingType::PredefinedType() const { return ::Ifc4::IfcDuctFittingTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcDuctFittingType::setPredefinedType(const ::Ifc4::IfcDuctFittingTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcDuctFittingTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDuctFittingType::Class() { return *((IfcParse::entity*)IFC4_types[308]); }
|
|
void Ifc4::IfcDuctFittingType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcDuctFittingTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcDuctFittingTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcDuctSegment
|
|
std::optional< ::Ifc4::IfcDuctSegmentTypeEnum::Value > Ifc4::IfcDuctSegment::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcDuctSegmentTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcDuctSegment::setPredefinedType(const std::optional< ::Ifc4::IfcDuctSegmentTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcDuctSegmentTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDuctSegment::Class() { return *((IfcParse::entity*)IFC4_types[310]); }
|
|
void Ifc4::IfcDuctSegment::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcDuctSegmentTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcDuctSegmentTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcDuctSegmentType
|
|
::Ifc4::IfcDuctSegmentTypeEnum::Value Ifc4::IfcDuctSegmentType::PredefinedType() const { return ::Ifc4::IfcDuctSegmentTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcDuctSegmentType::setPredefinedType(const ::Ifc4::IfcDuctSegmentTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcDuctSegmentTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDuctSegmentType::Class() { return *((IfcParse::entity*)IFC4_types[311]); }
|
|
void Ifc4::IfcDuctSegmentType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcDuctSegmentTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcDuctSegmentTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcDuctSilencer
|
|
std::optional< ::Ifc4::IfcDuctSilencerTypeEnum::Value > Ifc4::IfcDuctSilencer::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcDuctSilencerTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcDuctSilencer::setPredefinedType(const std::optional< ::Ifc4::IfcDuctSilencerTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcDuctSilencerTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDuctSilencer::Class() { return *((IfcParse::entity*)IFC4_types[313]); }
|
|
void Ifc4::IfcDuctSilencer::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcDuctSilencerTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcDuctSilencerTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcDuctSilencerType
|
|
::Ifc4::IfcDuctSilencerTypeEnum::Value Ifc4::IfcDuctSilencerType::PredefinedType() const { return ::Ifc4::IfcDuctSilencerTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcDuctSilencerType::setPredefinedType(const ::Ifc4::IfcDuctSilencerTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcDuctSilencerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcDuctSilencerType::Class() { return *((IfcParse::entity*)IFC4_types[314]); }
|
|
void Ifc4::IfcDuctSilencerType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcDuctSilencerTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcDuctSilencerTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcEdge
|
|
::Ifc4::IfcVertex Ifc4::IfcEdge::EdgeStart() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcVertex>(); }
|
|
void Ifc4::IfcEdge::setEdgeStart(const ::Ifc4::IfcVertex& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcVertex Ifc4::IfcEdge::EdgeEnd() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcVertex>(); }
|
|
void Ifc4::IfcEdge::setEdgeEnd(const ::Ifc4::IfcVertex& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcEdge::Class() { return *((IfcParse::entity*)IFC4_types[318]); }
|
|
void Ifc4::IfcEdge::initialize(::Ifc4::IfcVertex v1_EdgeStart, ::Ifc4::IfcVertex v2_EdgeEnd) { set_attribute_value(0, (v1_EdgeStart));set_attribute_value(1, (v2_EdgeEnd)); }
|
|
|
|
// Function implementations for IfcEdgeCurve
|
|
::Ifc4::IfcCurve Ifc4::IfcEdgeCurve::EdgeGeometry() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcCurve>(); }
|
|
void Ifc4::IfcEdgeCurve::setEdgeGeometry(const ::Ifc4::IfcCurve& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
bool Ifc4::IfcEdgeCurve::SameSense() const { bool v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcEdgeCurve::setSameSense(const bool& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcEdgeCurve::Class() { return *((IfcParse::entity*)IFC4_types[319]); }
|
|
void Ifc4::IfcEdgeCurve::initialize(::Ifc4::IfcVertex v1_EdgeStart, ::Ifc4::IfcVertex v2_EdgeEnd, ::Ifc4::IfcCurve v3_EdgeGeometry, bool v4_SameSense) { set_attribute_value(0, (v1_EdgeStart));set_attribute_value(1, (v2_EdgeEnd));set_attribute_value(2, (v3_EdgeGeometry));set_attribute_value(3, (v4_SameSense)); }
|
|
|
|
// Function implementations for IfcEdgeLoop
|
|
std::vector< ::Ifc4::IfcOrientedEdge > Ifc4::IfcEdgeLoop::EdgeList() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcOrientedEdge>(es); }
|
|
void Ifc4::IfcEdgeLoop::setEdgeList(const std::vector< ::Ifc4::IfcOrientedEdge >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcEdgeLoop::Class() { return *((IfcParse::entity*)IFC4_types[320]); }
|
|
void Ifc4::IfcEdgeLoop::initialize(std::vector< ::Ifc4::IfcOrientedEdge > v1_EdgeList) { set_attribute_value(0, cast_vector<express::Base>(v1_EdgeList)); }
|
|
|
|
// Function implementations for IfcElectricAppliance
|
|
std::optional< ::Ifc4::IfcElectricApplianceTypeEnum::Value > Ifc4::IfcElectricAppliance::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcElectricApplianceTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcElectricAppliance::setPredefinedType(const std::optional< ::Ifc4::IfcElectricApplianceTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcElectricApplianceTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElectricAppliance::Class() { return *((IfcParse::entity*)IFC4_types[321]); }
|
|
void Ifc4::IfcElectricAppliance::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcElectricApplianceTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcElectricApplianceTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcElectricApplianceType
|
|
::Ifc4::IfcElectricApplianceTypeEnum::Value Ifc4::IfcElectricApplianceType::PredefinedType() const { return ::Ifc4::IfcElectricApplianceTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcElectricApplianceType::setPredefinedType(const ::Ifc4::IfcElectricApplianceTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcElectricApplianceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElectricApplianceType::Class() { return *((IfcParse::entity*)IFC4_types[322]); }
|
|
void Ifc4::IfcElectricApplianceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcElectricApplianceTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcElectricApplianceTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcElectricDistributionBoard
|
|
std::optional< ::Ifc4::IfcElectricDistributionBoardTypeEnum::Value > Ifc4::IfcElectricDistributionBoard::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcElectricDistributionBoardTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcElectricDistributionBoard::setPredefinedType(const std::optional< ::Ifc4::IfcElectricDistributionBoardTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcElectricDistributionBoardTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElectricDistributionBoard::Class() { return *((IfcParse::entity*)IFC4_types[328]); }
|
|
void Ifc4::IfcElectricDistributionBoard::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcElectricDistributionBoardTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcElectricDistributionBoardTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcElectricDistributionBoardType
|
|
::Ifc4::IfcElectricDistributionBoardTypeEnum::Value Ifc4::IfcElectricDistributionBoardType::PredefinedType() const { return ::Ifc4::IfcElectricDistributionBoardTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcElectricDistributionBoardType::setPredefinedType(const ::Ifc4::IfcElectricDistributionBoardTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcElectricDistributionBoardTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElectricDistributionBoardType::Class() { return *((IfcParse::entity*)IFC4_types[329]); }
|
|
void Ifc4::IfcElectricDistributionBoardType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcElectricDistributionBoardTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcElectricDistributionBoardTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcElectricFlowStorageDevice
|
|
std::optional< ::Ifc4::IfcElectricFlowStorageDeviceTypeEnum::Value > Ifc4::IfcElectricFlowStorageDevice::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcElectricFlowStorageDeviceTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcElectricFlowStorageDevice::setPredefinedType(const std::optional< ::Ifc4::IfcElectricFlowStorageDeviceTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcElectricFlowStorageDeviceTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElectricFlowStorageDevice::Class() { return *((IfcParse::entity*)IFC4_types[331]); }
|
|
void Ifc4::IfcElectricFlowStorageDevice::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcElectricFlowStorageDeviceTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcElectricFlowStorageDeviceTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcElectricFlowStorageDeviceType
|
|
::Ifc4::IfcElectricFlowStorageDeviceTypeEnum::Value Ifc4::IfcElectricFlowStorageDeviceType::PredefinedType() const { return ::Ifc4::IfcElectricFlowStorageDeviceTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcElectricFlowStorageDeviceType::setPredefinedType(const ::Ifc4::IfcElectricFlowStorageDeviceTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcElectricFlowStorageDeviceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElectricFlowStorageDeviceType::Class() { return *((IfcParse::entity*)IFC4_types[332]); }
|
|
void Ifc4::IfcElectricFlowStorageDeviceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcElectricFlowStorageDeviceTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcElectricFlowStorageDeviceTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcElectricGenerator
|
|
std::optional< ::Ifc4::IfcElectricGeneratorTypeEnum::Value > Ifc4::IfcElectricGenerator::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcElectricGeneratorTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcElectricGenerator::setPredefinedType(const std::optional< ::Ifc4::IfcElectricGeneratorTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcElectricGeneratorTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElectricGenerator::Class() { return *((IfcParse::entity*)IFC4_types[334]); }
|
|
void Ifc4::IfcElectricGenerator::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcElectricGeneratorTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcElectricGeneratorTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcElectricGeneratorType
|
|
::Ifc4::IfcElectricGeneratorTypeEnum::Value Ifc4::IfcElectricGeneratorType::PredefinedType() const { return ::Ifc4::IfcElectricGeneratorTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcElectricGeneratorType::setPredefinedType(const ::Ifc4::IfcElectricGeneratorTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcElectricGeneratorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElectricGeneratorType::Class() { return *((IfcParse::entity*)IFC4_types[335]); }
|
|
void Ifc4::IfcElectricGeneratorType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcElectricGeneratorTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcElectricGeneratorTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcElectricMotor
|
|
std::optional< ::Ifc4::IfcElectricMotorTypeEnum::Value > Ifc4::IfcElectricMotor::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcElectricMotorTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcElectricMotor::setPredefinedType(const std::optional< ::Ifc4::IfcElectricMotorTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcElectricMotorTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElectricMotor::Class() { return *((IfcParse::entity*)IFC4_types[337]); }
|
|
void Ifc4::IfcElectricMotor::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcElectricMotorTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcElectricMotorTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcElectricMotorType
|
|
::Ifc4::IfcElectricMotorTypeEnum::Value Ifc4::IfcElectricMotorType::PredefinedType() const { return ::Ifc4::IfcElectricMotorTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcElectricMotorType::setPredefinedType(const ::Ifc4::IfcElectricMotorTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcElectricMotorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElectricMotorType::Class() { return *((IfcParse::entity*)IFC4_types[338]); }
|
|
void Ifc4::IfcElectricMotorType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcElectricMotorTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcElectricMotorTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcElectricTimeControl
|
|
std::optional< ::Ifc4::IfcElectricTimeControlTypeEnum::Value > Ifc4::IfcElectricTimeControl::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcElectricTimeControlTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcElectricTimeControl::setPredefinedType(const std::optional< ::Ifc4::IfcElectricTimeControlTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcElectricTimeControlTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElectricTimeControl::Class() { return *((IfcParse::entity*)IFC4_types[341]); }
|
|
void Ifc4::IfcElectricTimeControl::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcElectricTimeControlTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcElectricTimeControlTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcElectricTimeControlType
|
|
::Ifc4::IfcElectricTimeControlTypeEnum::Value Ifc4::IfcElectricTimeControlType::PredefinedType() const { return ::Ifc4::IfcElectricTimeControlTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcElectricTimeControlType::setPredefinedType(const ::Ifc4::IfcElectricTimeControlTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcElectricTimeControlTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElectricTimeControlType::Class() { return *((IfcParse::entity*)IFC4_types[342]); }
|
|
void Ifc4::IfcElectricTimeControlType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcElectricTimeControlTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcElectricTimeControlTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcElement
|
|
std::optional< std::string > Ifc4::IfcElement::Tag() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::string v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcElement::setTag(const std::optional< std::string >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
|
|
std::vector<::Ifc4::IfcRelFillsElement> Ifc4::IfcElement::FillsVoids() const { return cast_vector<IfcRelFillsElement>(file()->getInverse(data()->id(), IFC4_types[833], 5)); }
|
|
std::vector<::Ifc4::IfcRelConnectsElements> Ifc4::IfcElement::ConnectedTo() const { return cast_vector<IfcRelConnectsElements>(file()->getInverse(data()->id(), IFC4_types[815], 5)); }
|
|
std::vector<::Ifc4::IfcRelInterferesElements> Ifc4::IfcElement::IsInterferedByElements() const { return cast_vector<IfcRelInterferesElements>(file()->getInverse(data()->id(), IFC4_types[835], 5)); }
|
|
std::vector<::Ifc4::IfcRelInterferesElements> Ifc4::IfcElement::InterferesElements() const { return cast_vector<IfcRelInterferesElements>(file()->getInverse(data()->id(), IFC4_types[835], 4)); }
|
|
std::vector<::Ifc4::IfcRelProjectsElement> Ifc4::IfcElement::HasProjections() const { return cast_vector<IfcRelProjectsElement>(file()->getInverse(data()->id(), IFC4_types[837], 4)); }
|
|
std::vector<::Ifc4::IfcRelReferencedInSpatialStructure> Ifc4::IfcElement::ReferencedInStructures() const { return cast_vector<IfcRelReferencedInSpatialStructure>(file()->getInverse(data()->id(), IFC4_types[838], 4)); }
|
|
std::vector<::Ifc4::IfcRelVoidsElement> Ifc4::IfcElement::HasOpenings() const { return cast_vector<IfcRelVoidsElement>(file()->getInverse(data()->id(), IFC4_types[844], 4)); }
|
|
std::vector<::Ifc4::IfcRelConnectsWithRealizingElements> Ifc4::IfcElement::IsConnectionRealization() const { return cast_vector<IfcRelConnectsWithRealizingElements>(file()->getInverse(data()->id(), IFC4_types[822], 7)); }
|
|
std::vector<::Ifc4::IfcRelSpaceBoundary> Ifc4::IfcElement::ProvidesBoundaries() const { return cast_vector<IfcRelSpaceBoundary>(file()->getInverse(data()->id(), IFC4_types[841], 5)); }
|
|
std::vector<::Ifc4::IfcRelConnectsElements> Ifc4::IfcElement::ConnectedFrom() const { return cast_vector<IfcRelConnectsElements>(file()->getInverse(data()->id(), IFC4_types[815], 6)); }
|
|
std::vector<::Ifc4::IfcRelContainedInSpatialStructure> Ifc4::IfcElement::ContainedInStructure() const { return cast_vector<IfcRelContainedInSpatialStructure>(file()->getInverse(data()->id(), IFC4_types[823], 4)); }
|
|
std::vector<::Ifc4::IfcRelCoversBldgElements> Ifc4::IfcElement::HasCoverings() const { return cast_vector<IfcRelCoversBldgElements>(file()->getInverse(data()->id(), IFC4_types[824], 4)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcElement::Class() { return *((IfcParse::entity*)IFC4_types[345]); }
|
|
void Ifc4::IfcElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcElementAssembly
|
|
std::optional< ::Ifc4::IfcAssemblyPlaceEnum::Value > Ifc4::IfcElementAssembly::AssemblyPlace() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcAssemblyPlaceEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcElementAssembly::setAssemblyPlace(const std::optional< ::Ifc4::IfcAssemblyPlaceEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcAssemblyPlaceEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
std::optional< ::Ifc4::IfcElementAssemblyTypeEnum::Value > Ifc4::IfcElementAssembly::PredefinedType() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } return ::Ifc4::IfcElementAssemblyTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcElementAssembly::setPredefinedType(const std::optional< ::Ifc4::IfcElementAssemblyTypeEnum::Value >& v) { if (v) {set_attribute_value(9, EnumerationReference(&::Ifc4::IfcElementAssemblyTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(9);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElementAssembly::Class() { return *((IfcParse::entity*)IFC4_types[347]); }
|
|
void Ifc4::IfcElementAssembly::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcAssemblyPlaceEnum::Value > v9_AssemblyPlace, std::optional< ::Ifc4::IfcElementAssemblyTypeEnum::Value > v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_AssemblyPlace) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcAssemblyPlaceEnum::Class(),(size_t)*v9_AssemblyPlace))); } if (v10_PredefinedType) {set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcElementAssemblyTypeEnum::Class(),(size_t)*v10_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcElementAssemblyType
|
|
::Ifc4::IfcElementAssemblyTypeEnum::Value Ifc4::IfcElementAssemblyType::PredefinedType() const { return ::Ifc4::IfcElementAssemblyTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcElementAssemblyType::setPredefinedType(const ::Ifc4::IfcElementAssemblyTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcElementAssemblyTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElementAssemblyType::Class() { return *((IfcParse::entity*)IFC4_types[348]); }
|
|
void Ifc4::IfcElementAssemblyType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcElementAssemblyTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcElementAssemblyTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcElementComponent
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElementComponent::Class() { return *((IfcParse::entity*)IFC4_types[350]); }
|
|
void Ifc4::IfcElementComponent::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcElementComponentType
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElementComponentType::Class() { return *((IfcParse::entity*)IFC4_types[351]); }
|
|
void Ifc4::IfcElementComponentType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcElementQuantity
|
|
std::optional< std::string > Ifc4::IfcElementQuantity::MethodOfMeasurement() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcElementQuantity::setMethodOfMeasurement(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::vector< ::Ifc4::IfcPhysicalQuantity > Ifc4::IfcElementQuantity::Quantities() const { std::vector<express::Base> es = get_attribute_value(5); return cast_vector<::Ifc4::IfcPhysicalQuantity>(es); }
|
|
void Ifc4::IfcElementQuantity::setQuantities(const std::vector< ::Ifc4::IfcPhysicalQuantity >& v) { set_attribute_value(5, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElementQuantity::Class() { return *((IfcParse::entity*)IFC4_types[353]); }
|
|
void Ifc4::IfcElementQuantity::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_MethodOfMeasurement, std::vector< ::Ifc4::IfcPhysicalQuantity > v6_Quantities) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(v6_Quantities)); }
|
|
|
|
// Function implementations for IfcElementType
|
|
std::optional< std::string > Ifc4::IfcElementType::ElementType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcElementType::setElementType(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElementType::Class() { return *((IfcParse::entity*)IFC4_types[354]); }
|
|
void Ifc4::IfcElementType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcElementarySurface
|
|
::Ifc4::IfcAxis2Placement3D Ifc4::IfcElementarySurface::Position() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcAxis2Placement3D>(); }
|
|
void Ifc4::IfcElementarySurface::setPosition(const ::Ifc4::IfcAxis2Placement3D& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcElementarySurface::Class() { return *((IfcParse::entity*)IFC4_types[346]); }
|
|
void Ifc4::IfcElementarySurface::initialize(::Ifc4::IfcAxis2Placement3D v1_Position) { set_attribute_value(0, (v1_Position)); }
|
|
|
|
// Function implementations for IfcEllipse
|
|
double Ifc4::IfcEllipse::SemiAxis1() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcEllipse::setSemiAxis1(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
double Ifc4::IfcEllipse::SemiAxis2() const { double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcEllipse::setSemiAxis2(const double& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcEllipse::Class() { return *((IfcParse::entity*)IFC4_types[355]); }
|
|
void Ifc4::IfcEllipse::initialize(::Ifc4::IfcAxis2Placement v1_Position, double v2_SemiAxis1, double v3_SemiAxis2) { set_attribute_value(0, (v1_Position));set_attribute_value(1, (v2_SemiAxis1));set_attribute_value(2, (v3_SemiAxis2)); }
|
|
|
|
// Function implementations for IfcEllipseProfileDef
|
|
double Ifc4::IfcEllipseProfileDef::SemiAxis1() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcEllipseProfileDef::setSemiAxis1(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
double Ifc4::IfcEllipseProfileDef::SemiAxis2() const { double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcEllipseProfileDef::setSemiAxis2(const double& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcEllipseProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[356]); }
|
|
void Ifc4::IfcEllipseProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcAxis2Placement2D v3_Position, double v4_SemiAxis1, double v5_SemiAxis2) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Position));set_attribute_value(3, (v4_SemiAxis1));set_attribute_value(4, (v5_SemiAxis2)); }
|
|
|
|
// Function implementations for IfcEnergyConversionDevice
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcEnergyConversionDevice::Class() { return *((IfcParse::entity*)IFC4_types[357]); }
|
|
void Ifc4::IfcEnergyConversionDevice::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcEnergyConversionDeviceType
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcEnergyConversionDeviceType::Class() { return *((IfcParse::entity*)IFC4_types[358]); }
|
|
void Ifc4::IfcEnergyConversionDeviceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcEngine
|
|
std::optional< ::Ifc4::IfcEngineTypeEnum::Value > Ifc4::IfcEngine::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcEngineTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcEngine::setPredefinedType(const std::optional< ::Ifc4::IfcEngineTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcEngineTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcEngine::Class() { return *((IfcParse::entity*)IFC4_types[360]); }
|
|
void Ifc4::IfcEngine::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcEngineTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcEngineTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcEngineType
|
|
::Ifc4::IfcEngineTypeEnum::Value Ifc4::IfcEngineType::PredefinedType() const { return ::Ifc4::IfcEngineTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcEngineType::setPredefinedType(const ::Ifc4::IfcEngineTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcEngineTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcEngineType::Class() { return *((IfcParse::entity*)IFC4_types[361]); }
|
|
void Ifc4::IfcEngineType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcEngineTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcEngineTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcEvaporativeCooler
|
|
std::optional< ::Ifc4::IfcEvaporativeCoolerTypeEnum::Value > Ifc4::IfcEvaporativeCooler::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcEvaporativeCoolerTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcEvaporativeCooler::setPredefinedType(const std::optional< ::Ifc4::IfcEvaporativeCoolerTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcEvaporativeCoolerTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcEvaporativeCooler::Class() { return *((IfcParse::entity*)IFC4_types[363]); }
|
|
void Ifc4::IfcEvaporativeCooler::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcEvaporativeCoolerTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcEvaporativeCoolerTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcEvaporativeCoolerType
|
|
::Ifc4::IfcEvaporativeCoolerTypeEnum::Value Ifc4::IfcEvaporativeCoolerType::PredefinedType() const { return ::Ifc4::IfcEvaporativeCoolerTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcEvaporativeCoolerType::setPredefinedType(const ::Ifc4::IfcEvaporativeCoolerTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcEvaporativeCoolerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcEvaporativeCoolerType::Class() { return *((IfcParse::entity*)IFC4_types[364]); }
|
|
void Ifc4::IfcEvaporativeCoolerType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcEvaporativeCoolerTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcEvaporativeCoolerTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcEvaporator
|
|
std::optional< ::Ifc4::IfcEvaporatorTypeEnum::Value > Ifc4::IfcEvaporator::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcEvaporatorTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcEvaporator::setPredefinedType(const std::optional< ::Ifc4::IfcEvaporatorTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcEvaporatorTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcEvaporator::Class() { return *((IfcParse::entity*)IFC4_types[366]); }
|
|
void Ifc4::IfcEvaporator::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcEvaporatorTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcEvaporatorTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcEvaporatorType
|
|
::Ifc4::IfcEvaporatorTypeEnum::Value Ifc4::IfcEvaporatorType::PredefinedType() const { return ::Ifc4::IfcEvaporatorTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcEvaporatorType::setPredefinedType(const ::Ifc4::IfcEvaporatorTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcEvaporatorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcEvaporatorType::Class() { return *((IfcParse::entity*)IFC4_types[367]); }
|
|
void Ifc4::IfcEvaporatorType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcEvaporatorTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcEvaporatorTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcEvent
|
|
std::optional< ::Ifc4::IfcEventTypeEnum::Value > Ifc4::IfcEvent::PredefinedType() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } return ::Ifc4::IfcEventTypeEnum::FromString(get_attribute_value(7)); }
|
|
void Ifc4::IfcEvent::setPredefinedType(const std::optional< ::Ifc4::IfcEventTypeEnum::Value >& v) { if (v) {set_attribute_value(7, EnumerationReference(&::Ifc4::IfcEventTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(7);} }
|
|
std::optional< ::Ifc4::IfcEventTriggerTypeEnum::Value > Ifc4::IfcEvent::EventTriggerType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcEventTriggerTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcEvent::setEventTriggerType(const std::optional< ::Ifc4::IfcEventTriggerTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcEventTriggerTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
std::optional< std::string > Ifc4::IfcEvent::UserDefinedEventTriggerType() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } std::string v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcEvent::setUserDefinedEventTriggerType(const std::optional< std::string >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
::Ifc4::IfcEventTime Ifc4::IfcEvent::EventOccurenceTime() const { if(get_attribute_value(10).isNull()) { return ::Ifc4::IfcEventTime{}; } return ((express::Base)(get_attribute_value(10))).as<::Ifc4::IfcEventTime>(); }
|
|
void Ifc4::IfcEvent::setEventOccurenceTime(const ::Ifc4::IfcEventTime& v) { set_attribute_value(10, v);if constexpr (false)unset_attribute_value(10); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcEvent::Class() { return *((IfcParse::entity*)IFC4_types[369]); }
|
|
void Ifc4::IfcEvent::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< std::string > v7_LongDescription, std::optional< ::Ifc4::IfcEventTypeEnum::Value > v8_PredefinedType, std::optional< ::Ifc4::IfcEventTriggerTypeEnum::Value > v9_EventTriggerType, std::optional< std::string > v10_UserDefinedEventTriggerType, ::Ifc4::IfcEventTime v11_EventOccurenceTime) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_LongDescription) {set_attribute_value(6, (*v7_LongDescription)); } if (v8_PredefinedType) {set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcEventTypeEnum::Class(),(size_t)*v8_PredefinedType))); } if (v9_EventTriggerType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcEventTriggerTypeEnum::Class(),(size_t)*v9_EventTriggerType))); } if (v10_UserDefinedEventTriggerType) {set_attribute_value(9, (*v10_UserDefinedEventTriggerType)); }set_attribute_value(10, (v11_EventOccurenceTime)); }
|
|
|
|
// Function implementations for IfcEventTime
|
|
std::optional< std::string > Ifc4::IfcEventTime::ActualDate() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcEventTime::setActualDate(const std::optional< std::string >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< std::string > Ifc4::IfcEventTime::EarlyDate() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcEventTime::setEarlyDate(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcEventTime::LateDate() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcEventTime::setLateDate(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< std::string > Ifc4::IfcEventTime::ScheduleDate() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcEventTime::setScheduleDate(const std::optional< std::string >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcEventTime::Class() { return *((IfcParse::entity*)IFC4_types[370]); }
|
|
void Ifc4::IfcEventTime::initialize(std::optional< std::string > v1_Name, std::optional< ::Ifc4::IfcDataOriginEnum::Value > v2_DataOrigin, std::optional< std::string > v3_UserDefinedDataOrigin, std::optional< std::string > v4_ActualDate, std::optional< std::string > v5_EarlyDate, std::optional< std::string > v6_LateDate, std::optional< std::string > v7_ScheduleDate) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_DataOrigin) {set_attribute_value(1, (EnumerationReference(&::Ifc4::IfcDataOriginEnum::Class(),(size_t)*v2_DataOrigin))); } if (v3_UserDefinedDataOrigin) {set_attribute_value(2, (*v3_UserDefinedDataOrigin)); } if (v4_ActualDate) {set_attribute_value(3, (*v4_ActualDate)); } if (v5_EarlyDate) {set_attribute_value(4, (*v5_EarlyDate)); } if (v6_LateDate) {set_attribute_value(5, (*v6_LateDate)); } if (v7_ScheduleDate) {set_attribute_value(6, (*v7_ScheduleDate)); } }
|
|
|
|
// Function implementations for IfcEventType
|
|
::Ifc4::IfcEventTypeEnum::Value Ifc4::IfcEventType::PredefinedType() const { return ::Ifc4::IfcEventTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcEventType::setPredefinedType(const ::Ifc4::IfcEventTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcEventTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
::Ifc4::IfcEventTriggerTypeEnum::Value Ifc4::IfcEventType::EventTriggerType() const { return ::Ifc4::IfcEventTriggerTypeEnum::FromString(get_attribute_value(10)); }
|
|
void Ifc4::IfcEventType::setEventTriggerType(const ::Ifc4::IfcEventTriggerTypeEnum::Value& v) { set_attribute_value(10, EnumerationReference(&::Ifc4::IfcEventTriggerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(10); }
|
|
std::optional< std::string > Ifc4::IfcEventType::UserDefinedEventTriggerType() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } std::string v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcEventType::setUserDefinedEventTriggerType(const std::optional< std::string >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcEventType::Class() { return *((IfcParse::entity*)IFC4_types[372]); }
|
|
void Ifc4::IfcEventType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::string > v7_Identification, std::optional< std::string > v8_LongDescription, std::optional< std::string > v9_ProcessType, ::Ifc4::IfcEventTypeEnum::Value v10_PredefinedType, ::Ifc4::IfcEventTriggerTypeEnum::Value v11_EventTriggerType, std::optional< std::string > v12_UserDefinedEventTriggerType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_Identification) {set_attribute_value(6, (*v7_Identification)); } if (v8_LongDescription) {set_attribute_value(7, (*v8_LongDescription)); } if (v9_ProcessType) {set_attribute_value(8, (*v9_ProcessType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcEventTypeEnum::Class(),(size_t)v10_PredefinedType)));set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcEventTriggerTypeEnum::Class(),(size_t)v11_EventTriggerType))); if (v12_UserDefinedEventTriggerType) {set_attribute_value(11, (*v12_UserDefinedEventTriggerType)); } }
|
|
|
|
// Function implementations for IfcExtendedProperties
|
|
std::optional< std::string > Ifc4::IfcExtendedProperties::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcExtendedProperties::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< std::string > Ifc4::IfcExtendedProperties::Description() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcExtendedProperties::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::vector< ::Ifc4::IfcProperty > Ifc4::IfcExtendedProperties::Properties() const { std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcProperty>(es); }
|
|
void Ifc4::IfcExtendedProperties::setProperties(const std::vector< ::Ifc4::IfcProperty >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcExtendedProperties::Class() { return *((IfcParse::entity*)IFC4_types[374]); }
|
|
void Ifc4::IfcExtendedProperties::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, std::vector< ::Ifc4::IfcProperty > v3_Properties) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, cast_vector<express::Base>(v3_Properties)); }
|
|
|
|
// Function implementations for IfcExternalInformation
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcExternalInformation::Class() { return *((IfcParse::entity*)IFC4_types[375]); }
|
|
void Ifc4::IfcExternalInformation::initialize() { }
|
|
|
|
// Function implementations for IfcExternalReference
|
|
std::optional< std::string > Ifc4::IfcExternalReference::Location() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcExternalReference::setLocation(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< std::string > Ifc4::IfcExternalReference::Identification() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcExternalReference::setIdentification(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< std::string > Ifc4::IfcExternalReference::Name() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcExternalReference::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
|
|
std::vector<::Ifc4::IfcExternalReferenceRelationship> Ifc4::IfcExternalReference::ExternalReferenceForResources() const { return cast_vector<IfcExternalReferenceRelationship>(file()->getInverse(data()->id(), IFC4_types[380], 2)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcExternalReference::Class() { return *((IfcParse::entity*)IFC4_types[379]); }
|
|
void Ifc4::IfcExternalReference::initialize(std::optional< std::string > v1_Location, std::optional< std::string > v2_Identification, std::optional< std::string > v3_Name) { if (v1_Location) {set_attribute_value(0, (*v1_Location)); } if (v2_Identification) {set_attribute_value(1, (*v2_Identification)); } if (v3_Name) {set_attribute_value(2, (*v3_Name)); } }
|
|
|
|
// Function implementations for IfcExternalReferenceRelationship
|
|
::Ifc4::IfcExternalReference Ifc4::IfcExternalReferenceRelationship::RelatingReference() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcExternalReference>(); }
|
|
void Ifc4::IfcExternalReferenceRelationship::setRelatingReference(const ::Ifc4::IfcExternalReference& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
std::vector< ::Ifc4::IfcResourceObjectSelect > Ifc4::IfcExternalReferenceRelationship::RelatedResourceObjects() const { std::vector<express::Base> es = get_attribute_value(3); return cast_vector<::Ifc4::IfcResourceObjectSelect>(es); }
|
|
void Ifc4::IfcExternalReferenceRelationship::setRelatedResourceObjects(const std::vector< ::Ifc4::IfcResourceObjectSelect >& v) { set_attribute_value(3, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcExternalReferenceRelationship::Class() { return *((IfcParse::entity*)IFC4_types[380]); }
|
|
void Ifc4::IfcExternalReferenceRelationship::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcExternalReference v3_RelatingReference, std::vector< ::Ifc4::IfcResourceObjectSelect > v4_RelatedResourceObjects) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_RelatingReference));set_attribute_value(3, cast_vector<express::Base>(v4_RelatedResourceObjects)); }
|
|
|
|
// Function implementations for IfcExternalSpatialElement
|
|
std::optional< ::Ifc4::IfcExternalSpatialElementTypeEnum::Value > Ifc4::IfcExternalSpatialElement::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcExternalSpatialElementTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcExternalSpatialElement::setPredefinedType(const std::optional< ::Ifc4::IfcExternalSpatialElementTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcExternalSpatialElementTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
std::vector<::Ifc4::IfcRelSpaceBoundary> Ifc4::IfcExternalSpatialElement::BoundedBy() const { return cast_vector<IfcRelSpaceBoundary>(file()->getInverse(data()->id(), IFC4_types[841], 4)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcExternalSpatialElement::Class() { return *((IfcParse::entity*)IFC4_types[381]); }
|
|
void Ifc4::IfcExternalSpatialElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_LongName, std::optional< ::Ifc4::IfcExternalSpatialElementTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_LongName) {set_attribute_value(7, (*v8_LongName)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcExternalSpatialElementTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcExternalSpatialStructureElement
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcExternalSpatialStructureElement::Class() { return *((IfcParse::entity*)IFC4_types[383]); }
|
|
void Ifc4::IfcExternalSpatialStructureElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_LongName) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_LongName) {set_attribute_value(7, (*v8_LongName)); } }
|
|
|
|
// Function implementations for IfcExternallyDefinedHatchStyle
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcExternallyDefinedHatchStyle::Class() { return *((IfcParse::entity*)IFC4_types[376]); }
|
|
void Ifc4::IfcExternallyDefinedHatchStyle::initialize(std::optional< std::string > v1_Location, std::optional< std::string > v2_Identification, std::optional< std::string > v3_Name) { if (v1_Location) {set_attribute_value(0, (*v1_Location)); } if (v2_Identification) {set_attribute_value(1, (*v2_Identification)); } if (v3_Name) {set_attribute_value(2, (*v3_Name)); } }
|
|
|
|
// Function implementations for IfcExternallyDefinedSurfaceStyle
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcExternallyDefinedSurfaceStyle::Class() { return *((IfcParse::entity*)IFC4_types[377]); }
|
|
void Ifc4::IfcExternallyDefinedSurfaceStyle::initialize(std::optional< std::string > v1_Location, std::optional< std::string > v2_Identification, std::optional< std::string > v3_Name) { if (v1_Location) {set_attribute_value(0, (*v1_Location)); } if (v2_Identification) {set_attribute_value(1, (*v2_Identification)); } if (v3_Name) {set_attribute_value(2, (*v3_Name)); } }
|
|
|
|
// Function implementations for IfcExternallyDefinedTextFont
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcExternallyDefinedTextFont::Class() { return *((IfcParse::entity*)IFC4_types[378]); }
|
|
void Ifc4::IfcExternallyDefinedTextFont::initialize(std::optional< std::string > v1_Location, std::optional< std::string > v2_Identification, std::optional< std::string > v3_Name) { if (v1_Location) {set_attribute_value(0, (*v1_Location)); } if (v2_Identification) {set_attribute_value(1, (*v2_Identification)); } if (v3_Name) {set_attribute_value(2, (*v3_Name)); } }
|
|
|
|
// Function implementations for IfcExtrudedAreaSolid
|
|
::Ifc4::IfcDirection Ifc4::IfcExtrudedAreaSolid::ExtrudedDirection() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcDirection>(); }
|
|
void Ifc4::IfcExtrudedAreaSolid::setExtrudedDirection(const ::Ifc4::IfcDirection& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
double Ifc4::IfcExtrudedAreaSolid::Depth() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcExtrudedAreaSolid::setDepth(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcExtrudedAreaSolid::Class() { return *((IfcParse::entity*)IFC4_types[384]); }
|
|
void Ifc4::IfcExtrudedAreaSolid::initialize(::Ifc4::IfcProfileDef v1_SweptArea, ::Ifc4::IfcAxis2Placement3D v2_Position, ::Ifc4::IfcDirection v3_ExtrudedDirection, double v4_Depth) { set_attribute_value(0, (v1_SweptArea));set_attribute_value(1, (v2_Position));set_attribute_value(2, (v3_ExtrudedDirection));set_attribute_value(3, (v4_Depth)); }
|
|
|
|
// Function implementations for IfcExtrudedAreaSolidTapered
|
|
::Ifc4::IfcProfileDef Ifc4::IfcExtrudedAreaSolidTapered::EndSweptArea() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcProfileDef>(); }
|
|
void Ifc4::IfcExtrudedAreaSolidTapered::setEndSweptArea(const ::Ifc4::IfcProfileDef& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcExtrudedAreaSolidTapered::Class() { return *((IfcParse::entity*)IFC4_types[385]); }
|
|
void Ifc4::IfcExtrudedAreaSolidTapered::initialize(::Ifc4::IfcProfileDef v1_SweptArea, ::Ifc4::IfcAxis2Placement3D v2_Position, ::Ifc4::IfcDirection v3_ExtrudedDirection, double v4_Depth, ::Ifc4::IfcProfileDef v5_EndSweptArea) { set_attribute_value(0, (v1_SweptArea));set_attribute_value(1, (v2_Position));set_attribute_value(2, (v3_ExtrudedDirection));set_attribute_value(3, (v4_Depth));set_attribute_value(4, (v5_EndSweptArea)); }
|
|
|
|
// Function implementations for IfcFace
|
|
std::vector< ::Ifc4::IfcFaceBound > Ifc4::IfcFace::Bounds() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcFaceBound>(es); }
|
|
void Ifc4::IfcFace::setBounds(const std::vector< ::Ifc4::IfcFaceBound >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
|
|
std::vector<::Ifc4::IfcTextureMap> Ifc4::IfcFace::HasTextureMaps() const { return cast_vector<IfcTextureMap>(file()->getInverse(data()->id(), IFC4_types[1068], 2)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcFace::Class() { return *((IfcParse::entity*)IFC4_types[386]); }
|
|
void Ifc4::IfcFace::initialize(std::vector< ::Ifc4::IfcFaceBound > v1_Bounds) { set_attribute_value(0, cast_vector<express::Base>(v1_Bounds)); }
|
|
|
|
// Function implementations for IfcFaceBasedSurfaceModel
|
|
std::vector< ::Ifc4::IfcConnectedFaceSet > Ifc4::IfcFaceBasedSurfaceModel::FbsmFaces() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcConnectedFaceSet>(es); }
|
|
void Ifc4::IfcFaceBasedSurfaceModel::setFbsmFaces(const std::vector< ::Ifc4::IfcConnectedFaceSet >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFaceBasedSurfaceModel::Class() { return *((IfcParse::entity*)IFC4_types[387]); }
|
|
void Ifc4::IfcFaceBasedSurfaceModel::initialize(std::vector< ::Ifc4::IfcConnectedFaceSet > v1_FbsmFaces) { set_attribute_value(0, cast_vector<express::Base>(v1_FbsmFaces)); }
|
|
|
|
// Function implementations for IfcFaceBound
|
|
::Ifc4::IfcLoop Ifc4::IfcFaceBound::Bound() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcLoop>(); }
|
|
void Ifc4::IfcFaceBound::setBound(const ::Ifc4::IfcLoop& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
bool Ifc4::IfcFaceBound::Orientation() const { bool v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcFaceBound::setOrientation(const bool& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFaceBound::Class() { return *((IfcParse::entity*)IFC4_types[388]); }
|
|
void Ifc4::IfcFaceBound::initialize(::Ifc4::IfcLoop v1_Bound, bool v2_Orientation) { set_attribute_value(0, (v1_Bound));set_attribute_value(1, (v2_Orientation)); }
|
|
|
|
// Function implementations for IfcFaceOuterBound
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFaceOuterBound::Class() { return *((IfcParse::entity*)IFC4_types[389]); }
|
|
void Ifc4::IfcFaceOuterBound::initialize(::Ifc4::IfcLoop v1_Bound, bool v2_Orientation) { set_attribute_value(0, (v1_Bound));set_attribute_value(1, (v2_Orientation)); }
|
|
|
|
// Function implementations for IfcFaceSurface
|
|
::Ifc4::IfcSurface Ifc4::IfcFaceSurface::FaceSurface() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcSurface>(); }
|
|
void Ifc4::IfcFaceSurface::setFaceSurface(const ::Ifc4::IfcSurface& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
bool Ifc4::IfcFaceSurface::SameSense() const { bool v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcFaceSurface::setSameSense(const bool& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFaceSurface::Class() { return *((IfcParse::entity*)IFC4_types[390]); }
|
|
void Ifc4::IfcFaceSurface::initialize(std::vector< ::Ifc4::IfcFaceBound > v1_Bounds, ::Ifc4::IfcSurface v2_FaceSurface, bool v3_SameSense) { set_attribute_value(0, cast_vector<express::Base>(v1_Bounds));set_attribute_value(1, (v2_FaceSurface));set_attribute_value(2, (v3_SameSense)); }
|
|
|
|
// Function implementations for IfcFacetedBrep
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFacetedBrep::Class() { return *((IfcParse::entity*)IFC4_types[391]); }
|
|
void Ifc4::IfcFacetedBrep::initialize(::Ifc4::IfcClosedShell v1_Outer) { set_attribute_value(0, (v1_Outer)); }
|
|
|
|
// Function implementations for IfcFacetedBrepWithVoids
|
|
std::vector< ::Ifc4::IfcClosedShell > Ifc4::IfcFacetedBrepWithVoids::Voids() const { std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcClosedShell>(es); }
|
|
void Ifc4::IfcFacetedBrepWithVoids::setVoids(const std::vector< ::Ifc4::IfcClosedShell >& v) { set_attribute_value(1, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFacetedBrepWithVoids::Class() { return *((IfcParse::entity*)IFC4_types[392]); }
|
|
void Ifc4::IfcFacetedBrepWithVoids::initialize(::Ifc4::IfcClosedShell v1_Outer, std::vector< ::Ifc4::IfcClosedShell > v2_Voids) { set_attribute_value(0, (v1_Outer));set_attribute_value(1, cast_vector<express::Base>(v2_Voids)); }
|
|
|
|
// Function implementations for IfcFailureConnectionCondition
|
|
std::optional< double > Ifc4::IfcFailureConnectionCondition::TensionFailureX() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcFailureConnectionCondition::setTensionFailureX(const std::optional< double >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< double > Ifc4::IfcFailureConnectionCondition::TensionFailureY() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcFailureConnectionCondition::setTensionFailureY(const std::optional< double >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< double > Ifc4::IfcFailureConnectionCondition::TensionFailureZ() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcFailureConnectionCondition::setTensionFailureZ(const std::optional< double >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< double > Ifc4::IfcFailureConnectionCondition::CompressionFailureX() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcFailureConnectionCondition::setCompressionFailureX(const std::optional< double >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< double > Ifc4::IfcFailureConnectionCondition::CompressionFailureY() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcFailureConnectionCondition::setCompressionFailureY(const std::optional< double >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< double > Ifc4::IfcFailureConnectionCondition::CompressionFailureZ() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcFailureConnectionCondition::setCompressionFailureZ(const std::optional< double >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFailureConnectionCondition::Class() { return *((IfcParse::entity*)IFC4_types[393]); }
|
|
void Ifc4::IfcFailureConnectionCondition::initialize(std::optional< std::string > v1_Name, std::optional< double > v2_TensionFailureX, std::optional< double > v3_TensionFailureY, std::optional< double > v4_TensionFailureZ, std::optional< double > v5_CompressionFailureX, std::optional< double > v6_CompressionFailureY, std::optional< double > v7_CompressionFailureZ) { 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)); } }
|
|
|
|
// Function implementations for IfcFan
|
|
std::optional< ::Ifc4::IfcFanTypeEnum::Value > Ifc4::IfcFan::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcFanTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcFan::setPredefinedType(const std::optional< ::Ifc4::IfcFanTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcFanTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFan::Class() { return *((IfcParse::entity*)IFC4_types[394]); }
|
|
void Ifc4::IfcFan::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcFanTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcFanTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcFanType
|
|
::Ifc4::IfcFanTypeEnum::Value Ifc4::IfcFanType::PredefinedType() const { return ::Ifc4::IfcFanTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcFanType::setPredefinedType(const ::Ifc4::IfcFanTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcFanTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFanType::Class() { return *((IfcParse::entity*)IFC4_types[395]); }
|
|
void Ifc4::IfcFanType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcFanTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcFanTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcFastener
|
|
std::optional< ::Ifc4::IfcFastenerTypeEnum::Value > Ifc4::IfcFastener::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcFastenerTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcFastener::setPredefinedType(const std::optional< ::Ifc4::IfcFastenerTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcFastenerTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFastener::Class() { return *((IfcParse::entity*)IFC4_types[397]); }
|
|
void Ifc4::IfcFastener::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcFastenerTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcFastenerTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcFastenerType
|
|
::Ifc4::IfcFastenerTypeEnum::Value Ifc4::IfcFastenerType::PredefinedType() const { return ::Ifc4::IfcFastenerTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcFastenerType::setPredefinedType(const ::Ifc4::IfcFastenerTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcFastenerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFastenerType::Class() { return *((IfcParse::entity*)IFC4_types[398]); }
|
|
void Ifc4::IfcFastenerType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcFastenerTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcFastenerTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcFeatureElement
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFeatureElement::Class() { return *((IfcParse::entity*)IFC4_types[400]); }
|
|
void Ifc4::IfcFeatureElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcFeatureElementAddition
|
|
|
|
std::vector<::Ifc4::IfcRelProjectsElement> Ifc4::IfcFeatureElementAddition::ProjectsElements() const { return cast_vector<IfcRelProjectsElement>(file()->getInverse(data()->id(), IFC4_types[837], 5)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcFeatureElementAddition::Class() { return *((IfcParse::entity*)IFC4_types[401]); }
|
|
void Ifc4::IfcFeatureElementAddition::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcFeatureElementSubtraction
|
|
|
|
std::vector<::Ifc4::IfcRelVoidsElement> Ifc4::IfcFeatureElementSubtraction::VoidsElements() const { return cast_vector<IfcRelVoidsElement>(file()->getInverse(data()->id(), IFC4_types[844], 5)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcFeatureElementSubtraction::Class() { return *((IfcParse::entity*)IFC4_types[402]); }
|
|
void Ifc4::IfcFeatureElementSubtraction::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcFillAreaStyle
|
|
std::vector< ::Ifc4::IfcFillStyleSelect > Ifc4::IfcFillAreaStyle::FillStyles() const { std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcFillStyleSelect>(es); }
|
|
void Ifc4::IfcFillAreaStyle::setFillStyles(const std::vector< ::Ifc4::IfcFillStyleSelect >& v) { set_attribute_value(1, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(1); }
|
|
std::optional< bool > Ifc4::IfcFillAreaStyle::ModelorDraughting() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } bool v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcFillAreaStyle::setModelorDraughting(const std::optional< bool >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFillAreaStyle::Class() { return *((IfcParse::entity*)IFC4_types[403]); }
|
|
void Ifc4::IfcFillAreaStyle::initialize(std::optional< std::string > v1_Name, std::vector< ::Ifc4::IfcFillStyleSelect > v2_FillStyles, std::optional< bool > v3_ModelorDraughting) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, cast_vector<express::Base>(v2_FillStyles)); if (v3_ModelorDraughting) {set_attribute_value(2, (*v3_ModelorDraughting)); } }
|
|
|
|
// Function implementations for IfcFillAreaStyleHatching
|
|
::Ifc4::IfcCurveStyle Ifc4::IfcFillAreaStyleHatching::HatchLineAppearance() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcCurveStyle>(); }
|
|
void Ifc4::IfcFillAreaStyleHatching::setHatchLineAppearance(const ::Ifc4::IfcCurveStyle& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcHatchLineDistanceSelect Ifc4::IfcFillAreaStyleHatching::StartOfNextHatchLine() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcHatchLineDistanceSelect>(); }
|
|
void Ifc4::IfcFillAreaStyleHatching::setStartOfNextHatchLine(const ::Ifc4::IfcHatchLineDistanceSelect& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcCartesianPoint Ifc4::IfcFillAreaStyleHatching::PointOfReferenceHatchLine() const { if(get_attribute_value(2).isNull()) { return ::Ifc4::IfcCartesianPoint{}; } return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcCartesianPoint>(); }
|
|
void Ifc4::IfcFillAreaStyleHatching::setPointOfReferenceHatchLine(const ::Ifc4::IfcCartesianPoint& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcCartesianPoint Ifc4::IfcFillAreaStyleHatching::PatternStart() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcCartesianPoint{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcCartesianPoint>(); }
|
|
void Ifc4::IfcFillAreaStyleHatching::setPatternStart(const ::Ifc4::IfcCartesianPoint& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
double Ifc4::IfcFillAreaStyleHatching::HatchLineAngle() const { double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcFillAreaStyleHatching::setHatchLineAngle(const double& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFillAreaStyleHatching::Class() { return *((IfcParse::entity*)IFC4_types[404]); }
|
|
void Ifc4::IfcFillAreaStyleHatching::initialize(::Ifc4::IfcCurveStyle v1_HatchLineAppearance, ::Ifc4::IfcHatchLineDistanceSelect v2_StartOfNextHatchLine, ::Ifc4::IfcCartesianPoint v3_PointOfReferenceHatchLine, ::Ifc4::IfcCartesianPoint v4_PatternStart, double v5_HatchLineAngle) { set_attribute_value(0, (v1_HatchLineAppearance));set_attribute_value(1, (v2_StartOfNextHatchLine));set_attribute_value(2, (v3_PointOfReferenceHatchLine));set_attribute_value(3, (v4_PatternStart));set_attribute_value(4, (v5_HatchLineAngle)); }
|
|
|
|
// Function implementations for IfcFillAreaStyleTiles
|
|
std::vector< ::Ifc4::IfcVector > Ifc4::IfcFillAreaStyleTiles::TilingPattern() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcVector>(es); }
|
|
void Ifc4::IfcFillAreaStyleTiles::setTilingPattern(const std::vector< ::Ifc4::IfcVector >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
std::vector< ::Ifc4::IfcStyledItem > Ifc4::IfcFillAreaStyleTiles::Tiles() const { std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcStyledItem>(es); }
|
|
void Ifc4::IfcFillAreaStyleTiles::setTiles(const std::vector< ::Ifc4::IfcStyledItem >& v) { set_attribute_value(1, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(1); }
|
|
double Ifc4::IfcFillAreaStyleTiles::TilingScale() const { double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcFillAreaStyleTiles::setTilingScale(const double& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFillAreaStyleTiles::Class() { return *((IfcParse::entity*)IFC4_types[405]); }
|
|
void Ifc4::IfcFillAreaStyleTiles::initialize(std::vector< ::Ifc4::IfcVector > v1_TilingPattern, std::vector< ::Ifc4::IfcStyledItem > v2_Tiles, double v3_TilingScale) { set_attribute_value(0, cast_vector<express::Base>(v1_TilingPattern));set_attribute_value(1, cast_vector<express::Base>(v2_Tiles));set_attribute_value(2, (v3_TilingScale)); }
|
|
|
|
// Function implementations for IfcFilter
|
|
std::optional< ::Ifc4::IfcFilterTypeEnum::Value > Ifc4::IfcFilter::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcFilterTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcFilter::setPredefinedType(const std::optional< ::Ifc4::IfcFilterTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcFilterTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFilter::Class() { return *((IfcParse::entity*)IFC4_types[407]); }
|
|
void Ifc4::IfcFilter::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcFilterTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcFilterTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcFilterType
|
|
::Ifc4::IfcFilterTypeEnum::Value Ifc4::IfcFilterType::PredefinedType() const { return ::Ifc4::IfcFilterTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcFilterType::setPredefinedType(const ::Ifc4::IfcFilterTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcFilterTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFilterType::Class() { return *((IfcParse::entity*)IFC4_types[408]); }
|
|
void Ifc4::IfcFilterType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcFilterTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcFilterTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcFireSuppressionTerminal
|
|
std::optional< ::Ifc4::IfcFireSuppressionTerminalTypeEnum::Value > Ifc4::IfcFireSuppressionTerminal::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcFireSuppressionTerminalTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcFireSuppressionTerminal::setPredefinedType(const std::optional< ::Ifc4::IfcFireSuppressionTerminalTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcFireSuppressionTerminalTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFireSuppressionTerminal::Class() { return *((IfcParse::entity*)IFC4_types[410]); }
|
|
void Ifc4::IfcFireSuppressionTerminal::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcFireSuppressionTerminalTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcFireSuppressionTerminalTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcFireSuppressionTerminalType
|
|
::Ifc4::IfcFireSuppressionTerminalTypeEnum::Value Ifc4::IfcFireSuppressionTerminalType::PredefinedType() const { return ::Ifc4::IfcFireSuppressionTerminalTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcFireSuppressionTerminalType::setPredefinedType(const ::Ifc4::IfcFireSuppressionTerminalTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcFireSuppressionTerminalTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFireSuppressionTerminalType::Class() { return *((IfcParse::entity*)IFC4_types[411]); }
|
|
void Ifc4::IfcFireSuppressionTerminalType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcFireSuppressionTerminalTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcFireSuppressionTerminalTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcFixedReferenceSweptAreaSolid
|
|
::Ifc4::IfcCurve Ifc4::IfcFixedReferenceSweptAreaSolid::Directrix() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcCurve>(); }
|
|
void Ifc4::IfcFixedReferenceSweptAreaSolid::setDirectrix(const ::Ifc4::IfcCurve& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
std::optional< double > Ifc4::IfcFixedReferenceSweptAreaSolid::StartParam() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcFixedReferenceSweptAreaSolid::setStartParam(const std::optional< double >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< double > Ifc4::IfcFixedReferenceSweptAreaSolid::EndParam() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcFixedReferenceSweptAreaSolid::setEndParam(const std::optional< double >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
::Ifc4::IfcDirection Ifc4::IfcFixedReferenceSweptAreaSolid::FixedReference() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcDirection>(); }
|
|
void Ifc4::IfcFixedReferenceSweptAreaSolid::setFixedReference(const ::Ifc4::IfcDirection& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFixedReferenceSweptAreaSolid::Class() { return *((IfcParse::entity*)IFC4_types[413]); }
|
|
void Ifc4::IfcFixedReferenceSweptAreaSolid::initialize(::Ifc4::IfcProfileDef v1_SweptArea, ::Ifc4::IfcAxis2Placement3D v2_Position, ::Ifc4::IfcCurve v3_Directrix, std::optional< double > v4_StartParam, std::optional< double > v5_EndParam, ::Ifc4::IfcDirection v6_FixedReference) { set_attribute_value(0, (v1_SweptArea));set_attribute_value(1, (v2_Position));set_attribute_value(2, (v3_Directrix)); if (v4_StartParam) {set_attribute_value(3, (*v4_StartParam)); } if (v5_EndParam) {set_attribute_value(4, (*v5_EndParam)); }set_attribute_value(5, (v6_FixedReference)); }
|
|
|
|
// Function implementations for IfcFlowController
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowController::Class() { return *((IfcParse::entity*)IFC4_types[414]); }
|
|
void Ifc4::IfcFlowController::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcFlowControllerType
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowControllerType::Class() { return *((IfcParse::entity*)IFC4_types[415]); }
|
|
void Ifc4::IfcFlowControllerType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcFlowFitting
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowFitting::Class() { return *((IfcParse::entity*)IFC4_types[417]); }
|
|
void Ifc4::IfcFlowFitting::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcFlowFittingType
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowFittingType::Class() { return *((IfcParse::entity*)IFC4_types[418]); }
|
|
void Ifc4::IfcFlowFittingType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcFlowInstrument
|
|
std::optional< ::Ifc4::IfcFlowInstrumentTypeEnum::Value > Ifc4::IfcFlowInstrument::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcFlowInstrumentTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcFlowInstrument::setPredefinedType(const std::optional< ::Ifc4::IfcFlowInstrumentTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcFlowInstrumentTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowInstrument::Class() { return *((IfcParse::entity*)IFC4_types[419]); }
|
|
void Ifc4::IfcFlowInstrument::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcFlowInstrumentTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcFlowInstrumentTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcFlowInstrumentType
|
|
::Ifc4::IfcFlowInstrumentTypeEnum::Value Ifc4::IfcFlowInstrumentType::PredefinedType() const { return ::Ifc4::IfcFlowInstrumentTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcFlowInstrumentType::setPredefinedType(const ::Ifc4::IfcFlowInstrumentTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcFlowInstrumentTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowInstrumentType::Class() { return *((IfcParse::entity*)IFC4_types[420]); }
|
|
void Ifc4::IfcFlowInstrumentType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcFlowInstrumentTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcFlowInstrumentTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcFlowMeter
|
|
std::optional< ::Ifc4::IfcFlowMeterTypeEnum::Value > Ifc4::IfcFlowMeter::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcFlowMeterTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcFlowMeter::setPredefinedType(const std::optional< ::Ifc4::IfcFlowMeterTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcFlowMeterTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowMeter::Class() { return *((IfcParse::entity*)IFC4_types[422]); }
|
|
void Ifc4::IfcFlowMeter::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcFlowMeterTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcFlowMeterTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcFlowMeterType
|
|
::Ifc4::IfcFlowMeterTypeEnum::Value Ifc4::IfcFlowMeterType::PredefinedType() const { return ::Ifc4::IfcFlowMeterTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcFlowMeterType::setPredefinedType(const ::Ifc4::IfcFlowMeterTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcFlowMeterTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowMeterType::Class() { return *((IfcParse::entity*)IFC4_types[423]); }
|
|
void Ifc4::IfcFlowMeterType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcFlowMeterTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcFlowMeterTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcFlowMovingDevice
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowMovingDevice::Class() { return *((IfcParse::entity*)IFC4_types[425]); }
|
|
void Ifc4::IfcFlowMovingDevice::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcFlowMovingDeviceType
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowMovingDeviceType::Class() { return *((IfcParse::entity*)IFC4_types[426]); }
|
|
void Ifc4::IfcFlowMovingDeviceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcFlowSegment
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowSegment::Class() { return *((IfcParse::entity*)IFC4_types[427]); }
|
|
void Ifc4::IfcFlowSegment::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcFlowSegmentType
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowSegmentType::Class() { return *((IfcParse::entity*)IFC4_types[428]); }
|
|
void Ifc4::IfcFlowSegmentType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcFlowStorageDevice
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowStorageDevice::Class() { return *((IfcParse::entity*)IFC4_types[429]); }
|
|
void Ifc4::IfcFlowStorageDevice::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcFlowStorageDeviceType
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowStorageDeviceType::Class() { return *((IfcParse::entity*)IFC4_types[430]); }
|
|
void Ifc4::IfcFlowStorageDeviceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcFlowTerminal
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowTerminal::Class() { return *((IfcParse::entity*)IFC4_types[431]); }
|
|
void Ifc4::IfcFlowTerminal::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcFlowTerminalType
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowTerminalType::Class() { return *((IfcParse::entity*)IFC4_types[432]); }
|
|
void Ifc4::IfcFlowTerminalType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcFlowTreatmentDevice
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowTreatmentDevice::Class() { return *((IfcParse::entity*)IFC4_types[433]); }
|
|
void Ifc4::IfcFlowTreatmentDevice::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcFlowTreatmentDeviceType
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFlowTreatmentDeviceType::Class() { return *((IfcParse::entity*)IFC4_types[434]); }
|
|
void Ifc4::IfcFlowTreatmentDeviceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcFooting
|
|
std::optional< ::Ifc4::IfcFootingTypeEnum::Value > Ifc4::IfcFooting::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcFootingTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcFooting::setPredefinedType(const std::optional< ::Ifc4::IfcFootingTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcFootingTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFooting::Class() { return *((IfcParse::entity*)IFC4_types[438]); }
|
|
void Ifc4::IfcFooting::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcFootingTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcFootingTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcFootingType
|
|
::Ifc4::IfcFootingTypeEnum::Value Ifc4::IfcFootingType::PredefinedType() const { return ::Ifc4::IfcFootingTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcFootingType::setPredefinedType(const ::Ifc4::IfcFootingTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcFootingTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFootingType::Class() { return *((IfcParse::entity*)IFC4_types[439]); }
|
|
void Ifc4::IfcFootingType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcFootingTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcFootingTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcFurnishingElement
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFurnishingElement::Class() { return *((IfcParse::entity*)IFC4_types[443]); }
|
|
void Ifc4::IfcFurnishingElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcFurnishingElementType
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFurnishingElementType::Class() { return *((IfcParse::entity*)IFC4_types[444]); }
|
|
void Ifc4::IfcFurnishingElementType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcFurniture
|
|
std::optional< ::Ifc4::IfcFurnitureTypeEnum::Value > Ifc4::IfcFurniture::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcFurnitureTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcFurniture::setPredefinedType(const std::optional< ::Ifc4::IfcFurnitureTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcFurnitureTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFurniture::Class() { return *((IfcParse::entity*)IFC4_types[445]); }
|
|
void Ifc4::IfcFurniture::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcFurnitureTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcFurnitureTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcFurnitureType
|
|
::Ifc4::IfcAssemblyPlaceEnum::Value Ifc4::IfcFurnitureType::AssemblyPlace() const { return ::Ifc4::IfcAssemblyPlaceEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcFurnitureType::setAssemblyPlace(const ::Ifc4::IfcAssemblyPlaceEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcAssemblyPlaceEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
std::optional< ::Ifc4::IfcFurnitureTypeEnum::Value > Ifc4::IfcFurnitureType::PredefinedType() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } return ::Ifc4::IfcFurnitureTypeEnum::FromString(get_attribute_value(10)); }
|
|
void Ifc4::IfcFurnitureType::setPredefinedType(const std::optional< ::Ifc4::IfcFurnitureTypeEnum::Value >& v) { if (v) {set_attribute_value(10, EnumerationReference(&::Ifc4::IfcFurnitureTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(10);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcFurnitureType::Class() { return *((IfcParse::entity*)IFC4_types[446]); }
|
|
void Ifc4::IfcFurnitureType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcAssemblyPlaceEnum::Value v10_AssemblyPlace, std::optional< ::Ifc4::IfcFurnitureTypeEnum::Value > v11_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcAssemblyPlaceEnum::Class(),(size_t)v10_AssemblyPlace))); if (v11_PredefinedType) {set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcFurnitureTypeEnum::Class(),(size_t)*v11_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcGeographicElement
|
|
std::optional< ::Ifc4::IfcGeographicElementTypeEnum::Value > Ifc4::IfcGeographicElement::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcGeographicElementTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcGeographicElement::setPredefinedType(const std::optional< ::Ifc4::IfcGeographicElementTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcGeographicElementTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcGeographicElement::Class() { return *((IfcParse::entity*)IFC4_types[448]); }
|
|
void Ifc4::IfcGeographicElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcGeographicElementTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcGeographicElementTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcGeographicElementType
|
|
::Ifc4::IfcGeographicElementTypeEnum::Value Ifc4::IfcGeographicElementType::PredefinedType() const { return ::Ifc4::IfcGeographicElementTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcGeographicElementType::setPredefinedType(const ::Ifc4::IfcGeographicElementTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcGeographicElementTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcGeographicElementType::Class() { return *((IfcParse::entity*)IFC4_types[449]); }
|
|
void Ifc4::IfcGeographicElementType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcGeographicElementTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcGeographicElementTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcGeometricCurveSet
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcGeometricCurveSet::Class() { return *((IfcParse::entity*)IFC4_types[451]); }
|
|
void Ifc4::IfcGeometricCurveSet::initialize(std::vector< ::Ifc4::IfcGeometricSetSelect > v1_Elements) { set_attribute_value(0, cast_vector<express::Base>(v1_Elements)); }
|
|
|
|
// Function implementations for IfcGeometricRepresentationContext
|
|
int Ifc4::IfcGeometricRepresentationContext::CoordinateSpaceDimension() const { int v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcGeometricRepresentationContext::setCoordinateSpaceDimension(const int& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
std::optional< double > Ifc4::IfcGeometricRepresentationContext::Precision() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcGeometricRepresentationContext::setPrecision(const std::optional< double >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
::Ifc4::IfcAxis2Placement Ifc4::IfcGeometricRepresentationContext::WorldCoordinateSystem() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcAxis2Placement>(); }
|
|
void Ifc4::IfcGeometricRepresentationContext::setWorldCoordinateSystem(const ::Ifc4::IfcAxis2Placement& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcDirection Ifc4::IfcGeometricRepresentationContext::TrueNorth() const { if(get_attribute_value(5).isNull()) { return ::Ifc4::IfcDirection{}; } return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcDirection>(); }
|
|
void Ifc4::IfcGeometricRepresentationContext::setTrueNorth(const ::Ifc4::IfcDirection& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
std::vector<::Ifc4::IfcGeometricRepresentationSubContext> Ifc4::IfcGeometricRepresentationContext::HasSubContexts() const { return cast_vector<IfcGeometricRepresentationSubContext>(file()->getInverse(data()->id(), IFC4_types[455], 6)); }
|
|
std::vector<::Ifc4::IfcCoordinateOperation> Ifc4::IfcGeometricRepresentationContext::HasCoordinateOperation() const { return cast_vector<IfcCoordinateOperation>(file()->getInverse(data()->id(), IFC4_types[213], 0)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcGeometricRepresentationContext::Class() { return *((IfcParse::entity*)IFC4_types[453]); }
|
|
void Ifc4::IfcGeometricRepresentationContext::initialize(std::optional< std::string > v1_ContextIdentifier, std::optional< std::string > v2_ContextType, int v3_CoordinateSpaceDimension, std::optional< double > v4_Precision, ::Ifc4::IfcAxis2Placement v5_WorldCoordinateSystem, ::Ifc4::IfcDirection v6_TrueNorth) { 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));set_attribute_value(5, (v6_TrueNorth)); }
|
|
|
|
// Function implementations for IfcGeometricRepresentationItem
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcGeometricRepresentationItem::Class() { return *((IfcParse::entity*)IFC4_types[454]); }
|
|
void Ifc4::IfcGeometricRepresentationItem::initialize() { }
|
|
|
|
// Function implementations for IfcGeometricRepresentationSubContext
|
|
::Ifc4::IfcGeometricRepresentationContext Ifc4::IfcGeometricRepresentationSubContext::ParentContext() const { return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcGeometricRepresentationContext>(); }
|
|
void Ifc4::IfcGeometricRepresentationSubContext::setParentContext(const ::Ifc4::IfcGeometricRepresentationContext& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
std::optional< double > Ifc4::IfcGeometricRepresentationSubContext::TargetScale() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcGeometricRepresentationSubContext::setTargetScale(const std::optional< double >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
::Ifc4::IfcGeometricProjectionEnum::Value Ifc4::IfcGeometricRepresentationSubContext::TargetView() const { return ::Ifc4::IfcGeometricProjectionEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcGeometricRepresentationSubContext::setTargetView(const ::Ifc4::IfcGeometricProjectionEnum::Value& v) { set_attribute_value(8, EnumerationReference(&::Ifc4::IfcGeometricProjectionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }
|
|
std::optional< std::string > Ifc4::IfcGeometricRepresentationSubContext::UserDefinedTargetView() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } std::string v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcGeometricRepresentationSubContext::setUserDefinedTargetView(const std::optional< std::string >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcGeometricRepresentationSubContext::Class() { return *((IfcParse::entity*)IFC4_types[455]); }
|
|
void Ifc4::IfcGeometricRepresentationSubContext::initialize(std::optional< std::string > v1_ContextIdentifier, std::optional< std::string > v2_ContextType, ::Ifc4::IfcGeometricRepresentationContext v7_ParentContext, std::optional< double > v8_TargetScale, ::Ifc4::IfcGeometricProjectionEnum::Value v9_TargetView, std::optional< std::string > v10_UserDefinedTargetView) { if (v1_ContextIdentifier) {set_attribute_value(0, (*v1_ContextIdentifier)); } if (v2_ContextType) {set_attribute_value(1, (*v2_ContextType)); }set_attribute_value(6, (v7_ParentContext)); if (v8_TargetScale) {set_attribute_value(7, (*v8_TargetScale)); }set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcGeometricProjectionEnum::Class(),(size_t)v9_TargetView))); if (v10_UserDefinedTargetView) {set_attribute_value(9, (*v10_UserDefinedTargetView)); } }
|
|
|
|
// Function implementations for IfcGeometricSet
|
|
std::vector< ::Ifc4::IfcGeometricSetSelect > Ifc4::IfcGeometricSet::Elements() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcGeometricSetSelect>(es); }
|
|
void Ifc4::IfcGeometricSet::setElements(const std::vector< ::Ifc4::IfcGeometricSetSelect >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcGeometricSet::Class() { return *((IfcParse::entity*)IFC4_types[456]); }
|
|
void Ifc4::IfcGeometricSet::initialize(std::vector< ::Ifc4::IfcGeometricSetSelect > v1_Elements) { set_attribute_value(0, cast_vector<express::Base>(v1_Elements)); }
|
|
|
|
// Function implementations for IfcGrid
|
|
std::vector< ::Ifc4::IfcGridAxis > Ifc4::IfcGrid::UAxes() const { std::vector<express::Base> es = get_attribute_value(7); return cast_vector<::Ifc4::IfcGridAxis>(es); }
|
|
void Ifc4::IfcGrid::setUAxes(const std::vector< ::Ifc4::IfcGridAxis >& v) { set_attribute_value(7, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(7); }
|
|
std::vector< ::Ifc4::IfcGridAxis > Ifc4::IfcGrid::VAxes() const { std::vector<express::Base> es = get_attribute_value(8); return cast_vector<::Ifc4::IfcGridAxis>(es); }
|
|
void Ifc4::IfcGrid::setVAxes(const std::vector< ::Ifc4::IfcGridAxis >& v) { set_attribute_value(8, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(8); }
|
|
std::optional< std::vector< ::Ifc4::IfcGridAxis > > Ifc4::IfcGrid::WAxes() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(9); return cast_vector<::Ifc4::IfcGridAxis>(es); }
|
|
void Ifc4::IfcGrid::setWAxes(const std::optional< std::vector< ::Ifc4::IfcGridAxis > >& v) { if (v) {set_attribute_value(9, cast_vector<express::Base>(*v));} else {unset_attribute_value(9);} }
|
|
std::optional< ::Ifc4::IfcGridTypeEnum::Value > Ifc4::IfcGrid::PredefinedType() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } return ::Ifc4::IfcGridTypeEnum::FromString(get_attribute_value(10)); }
|
|
void Ifc4::IfcGrid::setPredefinedType(const std::optional< ::Ifc4::IfcGridTypeEnum::Value >& v) { if (v) {set_attribute_value(10, EnumerationReference(&::Ifc4::IfcGridTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(10);} }
|
|
|
|
std::vector<::Ifc4::IfcRelContainedInSpatialStructure> Ifc4::IfcGrid::ContainedInStructure() const { return cast_vector<IfcRelContainedInSpatialStructure>(file()->getInverse(data()->id(), IFC4_types[823], 4)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcGrid::Class() { return *((IfcParse::entity*)IFC4_types[460]); }
|
|
void Ifc4::IfcGrid::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::vector< ::Ifc4::IfcGridAxis > v8_UAxes, std::vector< ::Ifc4::IfcGridAxis > v9_VAxes, std::optional< std::vector< ::Ifc4::IfcGridAxis > > v10_WAxes, std::optional< ::Ifc4::IfcGridTypeEnum::Value > v11_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, cast_vector<express::Base>(v8_UAxes));set_attribute_value(8, cast_vector<express::Base>(v9_VAxes)); if (v10_WAxes) {set_attribute_value(9, cast_vector<express::Base>(*v10_WAxes)); } if (v11_PredefinedType) {set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcGridTypeEnum::Class(),(size_t)*v11_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcGridAxis
|
|
std::optional< std::string > Ifc4::IfcGridAxis::AxisTag() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcGridAxis::setAxisTag(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
::Ifc4::IfcCurve Ifc4::IfcGridAxis::AxisCurve() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcCurve>(); }
|
|
void Ifc4::IfcGridAxis::setAxisCurve(const ::Ifc4::IfcCurve& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
bool Ifc4::IfcGridAxis::SameSense() const { bool v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcGridAxis::setSameSense(const bool& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
std::vector<::Ifc4::IfcGrid> Ifc4::IfcGridAxis::PartOfW() const { return cast_vector<IfcGrid>(file()->getInverse(data()->id(), IFC4_types[460], 9)); }
|
|
std::vector<::Ifc4::IfcGrid> Ifc4::IfcGridAxis::PartOfV() const { return cast_vector<IfcGrid>(file()->getInverse(data()->id(), IFC4_types[460], 8)); }
|
|
std::vector<::Ifc4::IfcGrid> Ifc4::IfcGridAxis::PartOfU() const { return cast_vector<IfcGrid>(file()->getInverse(data()->id(), IFC4_types[460], 7)); }
|
|
std::vector<::Ifc4::IfcVirtualGridIntersection> Ifc4::IfcGridAxis::HasIntersections() const { return cast_vector<IfcVirtualGridIntersection>(file()->getInverse(data()->id(), IFC4_types[1135], 0)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcGridAxis::Class() { return *((IfcParse::entity*)IFC4_types[461]); }
|
|
void Ifc4::IfcGridAxis::initialize(std::optional< std::string > v1_AxisTag, ::Ifc4::IfcCurve v2_AxisCurve, bool v3_SameSense) { if (v1_AxisTag) {set_attribute_value(0, (*v1_AxisTag)); }set_attribute_value(1, (v2_AxisCurve));set_attribute_value(2, (v3_SameSense)); }
|
|
|
|
// Function implementations for IfcGridPlacement
|
|
::Ifc4::IfcVirtualGridIntersection Ifc4::IfcGridPlacement::PlacementLocation() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcVirtualGridIntersection>(); }
|
|
void Ifc4::IfcGridPlacement::setPlacementLocation(const ::Ifc4::IfcVirtualGridIntersection& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcGridPlacementDirectionSelect Ifc4::IfcGridPlacement::PlacementRefDirection() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcGridPlacementDirectionSelect{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcGridPlacementDirectionSelect>(); }
|
|
void Ifc4::IfcGridPlacement::setPlacementRefDirection(const ::Ifc4::IfcGridPlacementDirectionSelect& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcGridPlacement::Class() { return *((IfcParse::entity*)IFC4_types[462]); }
|
|
void Ifc4::IfcGridPlacement::initialize(::Ifc4::IfcVirtualGridIntersection v1_PlacementLocation, ::Ifc4::IfcGridPlacementDirectionSelect v2_PlacementRefDirection) { set_attribute_value(0, (v1_PlacementLocation));set_attribute_value(1, (v2_PlacementRefDirection)); }
|
|
|
|
// Function implementations for IfcGroup
|
|
|
|
std::vector<::Ifc4::IfcRelAssignsToGroup> Ifc4::IfcGroup::IsGroupedBy() const { return cast_vector<IfcRelAssignsToGroup>(file()->getInverse(data()->id(), IFC4_types[801], 6)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcGroup::Class() { return *((IfcParse::entity*)IFC4_types[465]); }
|
|
void Ifc4::IfcGroup::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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)); } }
|
|
|
|
// Function implementations for IfcHalfSpaceSolid
|
|
::Ifc4::IfcSurface Ifc4::IfcHalfSpaceSolid::BaseSurface() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcSurface>(); }
|
|
void Ifc4::IfcHalfSpaceSolid::setBaseSurface(const ::Ifc4::IfcSurface& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
bool Ifc4::IfcHalfSpaceSolid::AgreementFlag() const { bool v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcHalfSpaceSolid::setAgreementFlag(const bool& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcHalfSpaceSolid::Class() { return *((IfcParse::entity*)IFC4_types[466]); }
|
|
void Ifc4::IfcHalfSpaceSolid::initialize(::Ifc4::IfcSurface v1_BaseSurface, bool v2_AgreementFlag) { set_attribute_value(0, (v1_BaseSurface));set_attribute_value(1, (v2_AgreementFlag)); }
|
|
|
|
// Function implementations for IfcHeatExchanger
|
|
std::optional< ::Ifc4::IfcHeatExchangerTypeEnum::Value > Ifc4::IfcHeatExchanger::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcHeatExchangerTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcHeatExchanger::setPredefinedType(const std::optional< ::Ifc4::IfcHeatExchangerTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcHeatExchangerTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcHeatExchanger::Class() { return *((IfcParse::entity*)IFC4_types[468]); }
|
|
void Ifc4::IfcHeatExchanger::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcHeatExchangerTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcHeatExchangerTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcHeatExchangerType
|
|
::Ifc4::IfcHeatExchangerTypeEnum::Value Ifc4::IfcHeatExchangerType::PredefinedType() const { return ::Ifc4::IfcHeatExchangerTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcHeatExchangerType::setPredefinedType(const ::Ifc4::IfcHeatExchangerTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcHeatExchangerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcHeatExchangerType::Class() { return *((IfcParse::entity*)IFC4_types[469]); }
|
|
void Ifc4::IfcHeatExchangerType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcHeatExchangerTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcHeatExchangerTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcHumidifier
|
|
std::optional< ::Ifc4::IfcHumidifierTypeEnum::Value > Ifc4::IfcHumidifier::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcHumidifierTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcHumidifier::setPredefinedType(const std::optional< ::Ifc4::IfcHumidifierTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcHumidifierTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcHumidifier::Class() { return *((IfcParse::entity*)IFC4_types[473]); }
|
|
void Ifc4::IfcHumidifier::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcHumidifierTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcHumidifierTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcHumidifierType
|
|
::Ifc4::IfcHumidifierTypeEnum::Value Ifc4::IfcHumidifierType::PredefinedType() const { return ::Ifc4::IfcHumidifierTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcHumidifierType::setPredefinedType(const ::Ifc4::IfcHumidifierTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcHumidifierTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcHumidifierType::Class() { return *((IfcParse::entity*)IFC4_types[474]); }
|
|
void Ifc4::IfcHumidifierType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcHumidifierTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcHumidifierTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcIShapeProfileDef
|
|
double Ifc4::IfcIShapeProfileDef::OverallWidth() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcIShapeProfileDef::setOverallWidth(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
double Ifc4::IfcIShapeProfileDef::OverallDepth() const { double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcIShapeProfileDef::setOverallDepth(const double& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
double Ifc4::IfcIShapeProfileDef::WebThickness() const { double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcIShapeProfileDef::setWebThickness(const double& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
double Ifc4::IfcIShapeProfileDef::FlangeThickness() const { double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcIShapeProfileDef::setFlangeThickness(const double& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
std::optional< double > Ifc4::IfcIShapeProfileDef::FilletRadius() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcIShapeProfileDef::setFilletRadius(const std::optional< double >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< double > Ifc4::IfcIShapeProfileDef::FlangeEdgeRadius() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } double v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcIShapeProfileDef::setFlangeEdgeRadius(const std::optional< double >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
std::optional< double > Ifc4::IfcIShapeProfileDef::FlangeSlope() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } double v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcIShapeProfileDef::setFlangeSlope(const std::optional< double >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcIShapeProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[498]); }
|
|
void Ifc4::IfcIShapeProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcAxis2Placement2D v3_Position, double v4_OverallWidth, double v5_OverallDepth, double v6_WebThickness, double v7_FlangeThickness, std::optional< double > v8_FilletRadius, std::optional< double > v9_FlangeEdgeRadius, std::optional< double > v10_FlangeSlope) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Position));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)); } if (v9_FlangeEdgeRadius) {set_attribute_value(8, (*v9_FlangeEdgeRadius)); } if (v10_FlangeSlope) {set_attribute_value(9, (*v10_FlangeSlope)); } }
|
|
|
|
// Function implementations for IfcImageTexture
|
|
std::string Ifc4::IfcImageTexture::URLReference() const { std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcImageTexture::setURLReference(const std::string& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcImageTexture::Class() { return *((IfcParse::entity*)IFC4_types[478]); }
|
|
void Ifc4::IfcImageTexture::initialize(bool v1_RepeatS, bool v2_RepeatT, std::optional< std::string > v3_Mode, ::Ifc4::IfcCartesianTransformationOperator2D v4_TextureTransform, std::optional< std::vector< std::string > /*[1:?]*/ > v5_Parameter, std::string v6_URLReference) { set_attribute_value(0, (v1_RepeatS));set_attribute_value(1, (v2_RepeatT)); if (v3_Mode) {set_attribute_value(2, (*v3_Mode)); }set_attribute_value(3, (v4_TextureTransform)); if (v5_Parameter) {set_attribute_value(4, (*v5_Parameter)); }set_attribute_value(5, (v6_URLReference)); }
|
|
|
|
// Function implementations for IfcIndexedColourMap
|
|
::Ifc4::IfcTessellatedFaceSet Ifc4::IfcIndexedColourMap::MappedTo() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcTessellatedFaceSet>(); }
|
|
void Ifc4::IfcIndexedColourMap::setMappedTo(const ::Ifc4::IfcTessellatedFaceSet& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< double > Ifc4::IfcIndexedColourMap::Opacity() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcIndexedColourMap::setOpacity(const std::optional< double >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
::Ifc4::IfcColourRgbList Ifc4::IfcIndexedColourMap::Colours() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcColourRgbList>(); }
|
|
void Ifc4::IfcIndexedColourMap::setColours(const ::Ifc4::IfcColourRgbList& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
std::vector< int > /*[1:?]*/ Ifc4::IfcIndexedColourMap::ColourIndex() const { std::vector< int > /*[1:?]*/ v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcIndexedColourMap::setColourIndex(const std::vector< int > /*[1:?]*/& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcIndexedColourMap::Class() { return *((IfcParse::entity*)IFC4_types[479]); }
|
|
void Ifc4::IfcIndexedColourMap::initialize(::Ifc4::IfcTessellatedFaceSet v1_MappedTo, std::optional< double > v2_Opacity, ::Ifc4::IfcColourRgbList v3_Colours, std::vector< int > /*[1:?]*/ v4_ColourIndex) { set_attribute_value(0, (v1_MappedTo)); if (v2_Opacity) {set_attribute_value(1, (*v2_Opacity)); }set_attribute_value(2, (v3_Colours));set_attribute_value(3, (v4_ColourIndex)); }
|
|
|
|
// Function implementations for IfcIndexedPolyCurve
|
|
::Ifc4::IfcCartesianPointList Ifc4::IfcIndexedPolyCurve::Points() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcCartesianPointList>(); }
|
|
void Ifc4::IfcIndexedPolyCurve::setPoints(const ::Ifc4::IfcCartesianPointList& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< std::vector< ::Ifc4::IfcSegmentIndexSelect > > Ifc4::IfcIndexedPolyCurve::Segments() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcSegmentIndexSelect>(es); }
|
|
void Ifc4::IfcIndexedPolyCurve::setSegments(const std::optional< std::vector< ::Ifc4::IfcSegmentIndexSelect > >& v) { if (v) {set_attribute_value(1, cast_vector<express::Base>(*v));} else {unset_attribute_value(1);} }
|
|
std::optional< bool > Ifc4::IfcIndexedPolyCurve::SelfIntersect() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } bool v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcIndexedPolyCurve::setSelfIntersect(const std::optional< bool >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcIndexedPolyCurve::Class() { return *((IfcParse::entity*)IFC4_types[480]); }
|
|
void Ifc4::IfcIndexedPolyCurve::initialize(::Ifc4::IfcCartesianPointList v1_Points, std::optional< std::vector< ::Ifc4::IfcSegmentIndexSelect > > v2_Segments, std::optional< bool > v3_SelfIntersect) { set_attribute_value(0, (v1_Points)); if (v2_Segments) {set_attribute_value(1, cast_vector<express::Base>(*v2_Segments)); } if (v3_SelfIntersect) {set_attribute_value(2, (*v3_SelfIntersect)); } }
|
|
|
|
// Function implementations for IfcIndexedPolygonalFace
|
|
std::vector< int > /*[3:?]*/ Ifc4::IfcIndexedPolygonalFace::CoordIndex() const { std::vector< int > /*[3:?]*/ v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcIndexedPolygonalFace::setCoordIndex(const std::vector< int > /*[3:?]*/& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
std::vector<::Ifc4::IfcPolygonalFaceSet> Ifc4::IfcIndexedPolygonalFace::ToFaceSet() const { return cast_vector<IfcPolygonalFaceSet>(file()->getInverse(data()->id(), IFC4_types[680], 2)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcIndexedPolygonalFace::Class() { return *((IfcParse::entity*)IFC4_types[481]); }
|
|
void Ifc4::IfcIndexedPolygonalFace::initialize(std::vector< int > /*[3:?]*/ v1_CoordIndex) { set_attribute_value(0, (v1_CoordIndex)); }
|
|
|
|
// Function implementations for IfcIndexedPolygonalFaceWithVoids
|
|
std::vector< std::vector< int > > Ifc4::IfcIndexedPolygonalFaceWithVoids::InnerCoordIndices() const { std::vector< std::vector< int > > v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcIndexedPolygonalFaceWithVoids::setInnerCoordIndices(const std::vector< std::vector< int > >& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcIndexedPolygonalFaceWithVoids::Class() { return *((IfcParse::entity*)IFC4_types[482]); }
|
|
void Ifc4::IfcIndexedPolygonalFaceWithVoids::initialize(std::vector< int > /*[3:?]*/ v1_CoordIndex, std::vector< std::vector< int > > v2_InnerCoordIndices) { set_attribute_value(0, (v1_CoordIndex));set_attribute_value(1, (v2_InnerCoordIndices)); }
|
|
|
|
// Function implementations for IfcIndexedTextureMap
|
|
::Ifc4::IfcTessellatedFaceSet Ifc4::IfcIndexedTextureMap::MappedTo() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcTessellatedFaceSet>(); }
|
|
void Ifc4::IfcIndexedTextureMap::setMappedTo(const ::Ifc4::IfcTessellatedFaceSet& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcTextureVertexList Ifc4::IfcIndexedTextureMap::TexCoords() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcTextureVertexList>(); }
|
|
void Ifc4::IfcIndexedTextureMap::setTexCoords(const ::Ifc4::IfcTextureVertexList& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcIndexedTextureMap::Class() { return *((IfcParse::entity*)IFC4_types[483]); }
|
|
void Ifc4::IfcIndexedTextureMap::initialize(std::vector< ::Ifc4::IfcSurfaceTexture > v1_Maps, ::Ifc4::IfcTessellatedFaceSet v2_MappedTo, ::Ifc4::IfcTextureVertexList v3_TexCoords) { set_attribute_value(0, cast_vector<express::Base>(v1_Maps));set_attribute_value(1, (v2_MappedTo));set_attribute_value(2, (v3_TexCoords)); }
|
|
|
|
// Function implementations for IfcIndexedTriangleTextureMap
|
|
std::optional< std::vector< std::vector< int > > > Ifc4::IfcIndexedTriangleTextureMap::TexCoordIndex() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::vector< std::vector< int > > v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcIndexedTriangleTextureMap::setTexCoordIndex(const std::optional< std::vector< std::vector< int > > >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcIndexedTriangleTextureMap::Class() { return *((IfcParse::entity*)IFC4_types[484]); }
|
|
void Ifc4::IfcIndexedTriangleTextureMap::initialize(std::vector< ::Ifc4::IfcSurfaceTexture > v1_Maps, ::Ifc4::IfcTessellatedFaceSet v2_MappedTo, ::Ifc4::IfcTextureVertexList v3_TexCoords, std::optional< std::vector< std::vector< int > > > v4_TexCoordIndex) { set_attribute_value(0, cast_vector<express::Base>(v1_Maps));set_attribute_value(1, (v2_MappedTo));set_attribute_value(2, (v3_TexCoords)); if (v4_TexCoordIndex) {set_attribute_value(3, (*v4_TexCoordIndex)); } }
|
|
|
|
// Function implementations for IfcInterceptor
|
|
std::optional< ::Ifc4::IfcInterceptorTypeEnum::Value > Ifc4::IfcInterceptor::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcInterceptorTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcInterceptor::setPredefinedType(const std::optional< ::Ifc4::IfcInterceptorTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcInterceptorTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcInterceptor::Class() { return *((IfcParse::entity*)IFC4_types[488]); }
|
|
void Ifc4::IfcInterceptor::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcInterceptorTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcInterceptorTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcInterceptorType
|
|
::Ifc4::IfcInterceptorTypeEnum::Value Ifc4::IfcInterceptorType::PredefinedType() const { return ::Ifc4::IfcInterceptorTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcInterceptorType::setPredefinedType(const ::Ifc4::IfcInterceptorTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcInterceptorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcInterceptorType::Class() { return *((IfcParse::entity*)IFC4_types[489]); }
|
|
void Ifc4::IfcInterceptorType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcInterceptorTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcInterceptorTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcIntersectionCurve
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcIntersectionCurve::Class() { return *((IfcParse::entity*)IFC4_types[492]); }
|
|
void Ifc4::IfcIntersectionCurve::initialize(::Ifc4::IfcCurve v1_Curve3D, std::vector< ::Ifc4::IfcPcurve > v2_AssociatedGeometry, ::Ifc4::IfcPreferredSurfaceCurveRepresentation::Value v3_MasterRepresentation) { set_attribute_value(0, (v1_Curve3D));set_attribute_value(1, cast_vector<express::Base>(v2_AssociatedGeometry));set_attribute_value(2, (EnumerationReference(&::Ifc4::IfcPreferredSurfaceCurveRepresentation::Class(),(size_t)v3_MasterRepresentation))); }
|
|
|
|
// Function implementations for IfcInventory
|
|
std::optional< ::Ifc4::IfcInventoryTypeEnum::Value > Ifc4::IfcInventory::PredefinedType() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } return ::Ifc4::IfcInventoryTypeEnum::FromString(get_attribute_value(5)); }
|
|
void Ifc4::IfcInventory::setPredefinedType(const std::optional< ::Ifc4::IfcInventoryTypeEnum::Value >& v) { if (v) {set_attribute_value(5, EnumerationReference(&::Ifc4::IfcInventoryTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(5);} }
|
|
::Ifc4::IfcActorSelect Ifc4::IfcInventory::Jurisdiction() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcActorSelect{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcActorSelect>(); }
|
|
void Ifc4::IfcInventory::setJurisdiction(const ::Ifc4::IfcActorSelect& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
std::optional< std::vector< ::Ifc4::IfcPerson > > Ifc4::IfcInventory::ResponsiblePersons() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(7); return cast_vector<::Ifc4::IfcPerson>(es); }
|
|
void Ifc4::IfcInventory::setResponsiblePersons(const std::optional< std::vector< ::Ifc4::IfcPerson > >& v) { if (v) {set_attribute_value(7, cast_vector<express::Base>(*v));} else {unset_attribute_value(7);} }
|
|
std::optional< std::string > Ifc4::IfcInventory::LastUpdateDate() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcInventory::setLastUpdateDate(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
::Ifc4::IfcCostValue Ifc4::IfcInventory::CurrentValue() const { if(get_attribute_value(9).isNull()) { return ::Ifc4::IfcCostValue{}; } return ((express::Base)(get_attribute_value(9))).as<::Ifc4::IfcCostValue>(); }
|
|
void Ifc4::IfcInventory::setCurrentValue(const ::Ifc4::IfcCostValue& v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }
|
|
::Ifc4::IfcCostValue Ifc4::IfcInventory::OriginalValue() const { if(get_attribute_value(10).isNull()) { return ::Ifc4::IfcCostValue{}; } return ((express::Base)(get_attribute_value(10))).as<::Ifc4::IfcCostValue>(); }
|
|
void Ifc4::IfcInventory::setOriginalValue(const ::Ifc4::IfcCostValue& v) { set_attribute_value(10, v);if constexpr (false)unset_attribute_value(10); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcInventory::Class() { return *((IfcParse::entity*)IFC4_types[493]); }
|
|
void Ifc4::IfcInventory::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< ::Ifc4::IfcInventoryTypeEnum::Value > v6_PredefinedType, ::Ifc4::IfcActorSelect v7_Jurisdiction, std::optional< std::vector< ::Ifc4::IfcPerson > > v8_ResponsiblePersons, std::optional< std::string > v9_LastUpdateDate, ::Ifc4::IfcCostValue v10_CurrentValue, ::Ifc4::IfcCostValue v11_OriginalValue) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_PredefinedType) {set_attribute_value(5, (EnumerationReference(&::Ifc4::IfcInventoryTypeEnum::Class(),(size_t)*v6_PredefinedType))); }set_attribute_value(6, (v7_Jurisdiction)); if (v8_ResponsiblePersons) {set_attribute_value(7, cast_vector<express::Base>(*v8_ResponsiblePersons)); } if (v9_LastUpdateDate) {set_attribute_value(8, (*v9_LastUpdateDate)); }set_attribute_value(9, (v10_CurrentValue));set_attribute_value(10, (v11_OriginalValue)); }
|
|
|
|
// Function implementations for IfcIrregularTimeSeries
|
|
std::vector< ::Ifc4::IfcIrregularTimeSeriesValue > Ifc4::IfcIrregularTimeSeries::Values() const { std::vector<express::Base> es = get_attribute_value(8); return cast_vector<::Ifc4::IfcIrregularTimeSeriesValue>(es); }
|
|
void Ifc4::IfcIrregularTimeSeries::setValues(const std::vector< ::Ifc4::IfcIrregularTimeSeriesValue >& v) { set_attribute_value(8, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(8); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcIrregularTimeSeries::Class() { return *((IfcParse::entity*)IFC4_types[496]); }
|
|
void Ifc4::IfcIrregularTimeSeries::initialize(std::string v1_Name, std::optional< std::string > v2_Description, std::string v3_StartTime, std::string v4_EndTime, ::Ifc4::IfcTimeSeriesDataTypeEnum::Value v5_TimeSeriesDataType, ::Ifc4::IfcDataOriginEnum::Value v6_DataOrigin, std::optional< std::string > v7_UserDefinedDataOrigin, ::Ifc4::IfcUnit v8_Unit, std::vector< ::Ifc4::IfcIrregularTimeSeriesValue > v9_Values) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_StartTime));set_attribute_value(3, (v4_EndTime));set_attribute_value(4, (EnumerationReference(&::Ifc4::IfcTimeSeriesDataTypeEnum::Class(),(size_t)v5_TimeSeriesDataType)));set_attribute_value(5, (EnumerationReference(&::Ifc4::IfcDataOriginEnum::Class(),(size_t)v6_DataOrigin))); if (v7_UserDefinedDataOrigin) {set_attribute_value(6, (*v7_UserDefinedDataOrigin)); }set_attribute_value(7, (v8_Unit));set_attribute_value(8, cast_vector<express::Base>(v9_Values)); }
|
|
|
|
// Function implementations for IfcIrregularTimeSeriesValue
|
|
std::string Ifc4::IfcIrregularTimeSeriesValue::TimeStamp() const { std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcIrregularTimeSeriesValue::setTimeStamp(const std::string& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::vector< ::Ifc4::IfcValue > Ifc4::IfcIrregularTimeSeriesValue::ListValues() const { std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcValue>(es); }
|
|
void Ifc4::IfcIrregularTimeSeriesValue::setListValues(const std::vector< ::Ifc4::IfcValue >& v) { set_attribute_value(1, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcIrregularTimeSeriesValue::Class() { return *((IfcParse::entity*)IFC4_types[497]); }
|
|
void Ifc4::IfcIrregularTimeSeriesValue::initialize(std::string v1_TimeStamp, std::vector< ::Ifc4::IfcValue > v2_ListValues) { set_attribute_value(0, (v1_TimeStamp));set_attribute_value(1, cast_vector<express::Base>(v2_ListValues)); }
|
|
|
|
// Function implementations for IfcJunctionBox
|
|
std::optional< ::Ifc4::IfcJunctionBoxTypeEnum::Value > Ifc4::IfcJunctionBox::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcJunctionBoxTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcJunctionBox::setPredefinedType(const std::optional< ::Ifc4::IfcJunctionBoxTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcJunctionBoxTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcJunctionBox::Class() { return *((IfcParse::entity*)IFC4_types[500]); }
|
|
void Ifc4::IfcJunctionBox::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcJunctionBoxTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcJunctionBoxTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcJunctionBoxType
|
|
::Ifc4::IfcJunctionBoxTypeEnum::Value Ifc4::IfcJunctionBoxType::PredefinedType() const { return ::Ifc4::IfcJunctionBoxTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcJunctionBoxType::setPredefinedType(const ::Ifc4::IfcJunctionBoxTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcJunctionBoxTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcJunctionBoxType::Class() { return *((IfcParse::entity*)IFC4_types[501]); }
|
|
void Ifc4::IfcJunctionBoxType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcJunctionBoxTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcJunctionBoxTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcLShapeProfileDef
|
|
double Ifc4::IfcLShapeProfileDef::Depth() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcLShapeProfileDef::setDepth(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< double > Ifc4::IfcLShapeProfileDef::Width() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcLShapeProfileDef::setWidth(const std::optional< double >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
double Ifc4::IfcLShapeProfileDef::Thickness() const { double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcLShapeProfileDef::setThickness(const double& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
std::optional< double > Ifc4::IfcLShapeProfileDef::FilletRadius() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcLShapeProfileDef::setFilletRadius(const std::optional< double >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
std::optional< double > Ifc4::IfcLShapeProfileDef::EdgeRadius() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcLShapeProfileDef::setEdgeRadius(const std::optional< double >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< double > Ifc4::IfcLShapeProfileDef::LegSlope() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } double v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcLShapeProfileDef::setLegSlope(const std::optional< double >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLShapeProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[545]); }
|
|
void Ifc4::IfcLShapeProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcAxis2Placement2D v3_Position, double v4_Depth, std::optional< double > v5_Width, double v6_Thickness, std::optional< double > v7_FilletRadius, std::optional< double > v8_EdgeRadius, std::optional< double > v9_LegSlope) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Position));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)); } }
|
|
|
|
// Function implementations for IfcLaborResource
|
|
std::optional< ::Ifc4::IfcLaborResourceTypeEnum::Value > Ifc4::IfcLaborResource::PredefinedType() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } return ::Ifc4::IfcLaborResourceTypeEnum::FromString(get_attribute_value(10)); }
|
|
void Ifc4::IfcLaborResource::setPredefinedType(const std::optional< ::Ifc4::IfcLaborResourceTypeEnum::Value >& v) { if (v) {set_attribute_value(10, EnumerationReference(&::Ifc4::IfcLaborResourceTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(10);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLaborResource::Class() { return *((IfcParse::entity*)IFC4_types[506]); }
|
|
void Ifc4::IfcLaborResource::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< std::string > v7_LongDescription, ::Ifc4::IfcResourceTime v8_Usage, std::optional< std::vector< ::Ifc4::IfcAppliedValue > > v9_BaseCosts, ::Ifc4::IfcPhysicalQuantity v10_BaseQuantity, std::optional< ::Ifc4::IfcLaborResourceTypeEnum::Value > v11_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_LongDescription) {set_attribute_value(6, (*v7_LongDescription)); }set_attribute_value(7, (v8_Usage)); if (v9_BaseCosts) {set_attribute_value(8, cast_vector<express::Base>(*v9_BaseCosts)); }set_attribute_value(9, (v10_BaseQuantity)); if (v11_PredefinedType) {set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcLaborResourceTypeEnum::Class(),(size_t)*v11_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcLaborResourceType
|
|
::Ifc4::IfcLaborResourceTypeEnum::Value Ifc4::IfcLaborResourceType::PredefinedType() const { return ::Ifc4::IfcLaborResourceTypeEnum::FromString(get_attribute_value(11)); }
|
|
void Ifc4::IfcLaborResourceType::setPredefinedType(const ::Ifc4::IfcLaborResourceTypeEnum::Value& v) { set_attribute_value(11, EnumerationReference(&::Ifc4::IfcLaborResourceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(11); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLaborResourceType::Class() { return *((IfcParse::entity*)IFC4_types[507]); }
|
|
void Ifc4::IfcLaborResourceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::string > v7_Identification, std::optional< std::string > v8_LongDescription, std::optional< std::string > v9_ResourceType, std::optional< std::vector< ::Ifc4::IfcAppliedValue > > v10_BaseCosts, ::Ifc4::IfcPhysicalQuantity v11_BaseQuantity, ::Ifc4::IfcLaborResourceTypeEnum::Value v12_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_Identification) {set_attribute_value(6, (*v7_Identification)); } if (v8_LongDescription) {set_attribute_value(7, (*v8_LongDescription)); } if (v9_ResourceType) {set_attribute_value(8, (*v9_ResourceType)); } if (v10_BaseCosts) {set_attribute_value(9, cast_vector<express::Base>(*v10_BaseCosts)); }set_attribute_value(10, (v11_BaseQuantity));set_attribute_value(11, (EnumerationReference(&::Ifc4::IfcLaborResourceTypeEnum::Class(),(size_t)v12_PredefinedType))); }
|
|
|
|
// Function implementations for IfcLagTime
|
|
::Ifc4::IfcTimeOrRatioSelect Ifc4::IfcLagTime::LagValue() const { return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcTimeOrRatioSelect>(); }
|
|
void Ifc4::IfcLagTime::setLagValue(const ::Ifc4::IfcTimeOrRatioSelect& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
::Ifc4::IfcTaskDurationEnum::Value Ifc4::IfcLagTime::DurationType() const { return ::Ifc4::IfcTaskDurationEnum::FromString(get_attribute_value(4)); }
|
|
void Ifc4::IfcLagTime::setDurationType(const ::Ifc4::IfcTaskDurationEnum::Value& v) { set_attribute_value(4, EnumerationReference(&::Ifc4::IfcTaskDurationEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLagTime::Class() { return *((IfcParse::entity*)IFC4_types[509]); }
|
|
void Ifc4::IfcLagTime::initialize(std::optional< std::string > v1_Name, std::optional< ::Ifc4::IfcDataOriginEnum::Value > v2_DataOrigin, std::optional< std::string > v3_UserDefinedDataOrigin, ::Ifc4::IfcTimeOrRatioSelect v4_LagValue, ::Ifc4::IfcTaskDurationEnum::Value v5_DurationType) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_DataOrigin) {set_attribute_value(1, (EnumerationReference(&::Ifc4::IfcDataOriginEnum::Class(),(size_t)*v2_DataOrigin))); } if (v3_UserDefinedDataOrigin) {set_attribute_value(2, (*v3_UserDefinedDataOrigin)); }set_attribute_value(3, (v4_LagValue));set_attribute_value(4, (EnumerationReference(&::Ifc4::IfcTaskDurationEnum::Class(),(size_t)v5_DurationType))); }
|
|
|
|
// Function implementations for IfcLamp
|
|
std::optional< ::Ifc4::IfcLampTypeEnum::Value > Ifc4::IfcLamp::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcLampTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcLamp::setPredefinedType(const std::optional< ::Ifc4::IfcLampTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcLampTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLamp::Class() { return *((IfcParse::entity*)IFC4_types[510]); }
|
|
void Ifc4::IfcLamp::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcLampTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcLampTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcLampType
|
|
::Ifc4::IfcLampTypeEnum::Value Ifc4::IfcLampType::PredefinedType() const { return ::Ifc4::IfcLampTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcLampType::setPredefinedType(const ::Ifc4::IfcLampTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcLampTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLampType::Class() { return *((IfcParse::entity*)IFC4_types[511]); }
|
|
void Ifc4::IfcLampType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcLampTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcLampTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcLibraryInformation
|
|
std::string Ifc4::IfcLibraryInformation::Name() const { std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcLibraryInformation::setName(const std::string& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< std::string > Ifc4::IfcLibraryInformation::Version() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcLibraryInformation::setVersion(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
::Ifc4::IfcActorSelect Ifc4::IfcLibraryInformation::Publisher() const { if(get_attribute_value(2).isNull()) { return ::Ifc4::IfcActorSelect{}; } return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcActorSelect>(); }
|
|
void Ifc4::IfcLibraryInformation::setPublisher(const ::Ifc4::IfcActorSelect& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
std::optional< std::string > Ifc4::IfcLibraryInformation::VersionDate() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcLibraryInformation::setVersionDate(const std::optional< std::string >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< std::string > Ifc4::IfcLibraryInformation::Location() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcLibraryInformation::setLocation(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcLibraryInformation::Description() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcLibraryInformation::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
|
|
std::vector<::Ifc4::IfcRelAssociatesLibrary> Ifc4::IfcLibraryInformation::LibraryInfoForObjects() const { return cast_vector<IfcRelAssociatesLibrary>(file()->getInverse(data()->id(), IFC4_types[811], 5)); }
|
|
std::vector<::Ifc4::IfcLibraryReference> Ifc4::IfcLibraryInformation::HasLibraryReferences() const { return cast_vector<IfcLibraryReference>(file()->getInverse(data()->id(), IFC4_types[518], 5)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcLibraryInformation::Class() { return *((IfcParse::entity*)IFC4_types[517]); }
|
|
void Ifc4::IfcLibraryInformation::initialize(std::string v1_Name, std::optional< std::string > v2_Version, ::Ifc4::IfcActorSelect v3_Publisher, std::optional< std::string > v4_VersionDate, std::optional< std::string > v5_Location, std::optional< std::string > v6_Description) { set_attribute_value(0, (v1_Name)); if (v2_Version) {set_attribute_value(1, (*v2_Version)); }set_attribute_value(2, (v3_Publisher)); if (v4_VersionDate) {set_attribute_value(3, (*v4_VersionDate)); } if (v5_Location) {set_attribute_value(4, (*v5_Location)); } if (v6_Description) {set_attribute_value(5, (*v6_Description)); } }
|
|
|
|
// Function implementations for IfcLibraryReference
|
|
std::optional< std::string > Ifc4::IfcLibraryReference::Description() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcLibraryReference::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< std::string > Ifc4::IfcLibraryReference::Language() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcLibraryReference::setLanguage(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
::Ifc4::IfcLibraryInformation Ifc4::IfcLibraryReference::ReferencedLibrary() const { if(get_attribute_value(5).isNull()) { return ::Ifc4::IfcLibraryInformation{}; } return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcLibraryInformation>(); }
|
|
void Ifc4::IfcLibraryReference::setReferencedLibrary(const ::Ifc4::IfcLibraryInformation& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
std::vector<::Ifc4::IfcRelAssociatesLibrary> Ifc4::IfcLibraryReference::LibraryRefForObjects() const { return cast_vector<IfcRelAssociatesLibrary>(file()->getInverse(data()->id(), IFC4_types[811], 5)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcLibraryReference::Class() { return *((IfcParse::entity*)IFC4_types[518]); }
|
|
void Ifc4::IfcLibraryReference::initialize(std::optional< std::string > v1_Location, std::optional< std::string > v2_Identification, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_Language, ::Ifc4::IfcLibraryInformation v6_ReferencedLibrary) { if (v1_Location) {set_attribute_value(0, (*v1_Location)); } if (v2_Identification) {set_attribute_value(1, (*v2_Identification)); } if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_Language) {set_attribute_value(4, (*v5_Language)); }set_attribute_value(5, (v6_ReferencedLibrary)); }
|
|
|
|
// Function implementations for IfcLightDistributionData
|
|
double Ifc4::IfcLightDistributionData::MainPlaneAngle() const { double v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcLightDistributionData::setMainPlaneAngle(const double& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::vector< double > /*[1:?]*/ Ifc4::IfcLightDistributionData::SecondaryPlaneAngle() const { std::vector< double > /*[1:?]*/ v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcLightDistributionData::setSecondaryPlaneAngle(const std::vector< double > /*[1:?]*/& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
std::vector< double > /*[1:?]*/ Ifc4::IfcLightDistributionData::LuminousIntensity() const { std::vector< double > /*[1:?]*/ v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcLightDistributionData::setLuminousIntensity(const std::vector< double > /*[1:?]*/& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLightDistributionData::Class() { return *((IfcParse::entity*)IFC4_types[521]); }
|
|
void Ifc4::IfcLightDistributionData::initialize(double v1_MainPlaneAngle, std::vector< double > /*[1:?]*/ v2_SecondaryPlaneAngle, std::vector< double > /*[1:?]*/ v3_LuminousIntensity) { set_attribute_value(0, (v1_MainPlaneAngle));set_attribute_value(1, (v2_SecondaryPlaneAngle));set_attribute_value(2, (v3_LuminousIntensity)); }
|
|
|
|
// Function implementations for IfcLightFixture
|
|
std::optional< ::Ifc4::IfcLightFixtureTypeEnum::Value > Ifc4::IfcLightFixture::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcLightFixtureTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcLightFixture::setPredefinedType(const std::optional< ::Ifc4::IfcLightFixtureTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcLightFixtureTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLightFixture::Class() { return *((IfcParse::entity*)IFC4_types[524]); }
|
|
void Ifc4::IfcLightFixture::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcLightFixtureTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcLightFixtureTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcLightFixtureType
|
|
::Ifc4::IfcLightFixtureTypeEnum::Value Ifc4::IfcLightFixtureType::PredefinedType() const { return ::Ifc4::IfcLightFixtureTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcLightFixtureType::setPredefinedType(const ::Ifc4::IfcLightFixtureTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcLightFixtureTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLightFixtureType::Class() { return *((IfcParse::entity*)IFC4_types[525]); }
|
|
void Ifc4::IfcLightFixtureType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcLightFixtureTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcLightFixtureTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcLightIntensityDistribution
|
|
::Ifc4::IfcLightDistributionCurveEnum::Value Ifc4::IfcLightIntensityDistribution::LightDistributionCurve() const { return ::Ifc4::IfcLightDistributionCurveEnum::FromString(get_attribute_value(0)); }
|
|
void Ifc4::IfcLightIntensityDistribution::setLightDistributionCurve(const ::Ifc4::IfcLightDistributionCurveEnum::Value& v) { set_attribute_value(0, EnumerationReference(&::Ifc4::IfcLightDistributionCurveEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(0); }
|
|
std::vector< ::Ifc4::IfcLightDistributionData > Ifc4::IfcLightIntensityDistribution::DistributionData() const { std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcLightDistributionData>(es); }
|
|
void Ifc4::IfcLightIntensityDistribution::setDistributionData(const std::vector< ::Ifc4::IfcLightDistributionData >& v) { set_attribute_value(1, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLightIntensityDistribution::Class() { return *((IfcParse::entity*)IFC4_types[527]); }
|
|
void Ifc4::IfcLightIntensityDistribution::initialize(::Ifc4::IfcLightDistributionCurveEnum::Value v1_LightDistributionCurve, std::vector< ::Ifc4::IfcLightDistributionData > v2_DistributionData) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcLightDistributionCurveEnum::Class(),(size_t)v1_LightDistributionCurve)));set_attribute_value(1, cast_vector<express::Base>(v2_DistributionData)); }
|
|
|
|
// Function implementations for IfcLightSource
|
|
std::optional< std::string > Ifc4::IfcLightSource::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcLightSource::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
::Ifc4::IfcColourRgb Ifc4::IfcLightSource::LightColour() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcColourRgb>(); }
|
|
void Ifc4::IfcLightSource::setLightColour(const ::Ifc4::IfcColourRgb& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
std::optional< double > Ifc4::IfcLightSource::AmbientIntensity() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcLightSource::setAmbientIntensity(const std::optional< double >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< double > Ifc4::IfcLightSource::Intensity() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcLightSource::setIntensity(const std::optional< double >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLightSource::Class() { return *((IfcParse::entity*)IFC4_types[528]); }
|
|
void Ifc4::IfcLightSource::initialize(std::optional< std::string > v1_Name, ::Ifc4::IfcColourRgb v2_LightColour, std::optional< double > v3_AmbientIntensity, std::optional< double > v4_Intensity) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (v2_LightColour)); if (v3_AmbientIntensity) {set_attribute_value(2, (*v3_AmbientIntensity)); } if (v4_Intensity) {set_attribute_value(3, (*v4_Intensity)); } }
|
|
|
|
// Function implementations for IfcLightSourceAmbient
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLightSourceAmbient::Class() { return *((IfcParse::entity*)IFC4_types[529]); }
|
|
void Ifc4::IfcLightSourceAmbient::initialize(std::optional< std::string > v1_Name, ::Ifc4::IfcColourRgb v2_LightColour, std::optional< double > v3_AmbientIntensity, std::optional< double > v4_Intensity) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (v2_LightColour)); if (v3_AmbientIntensity) {set_attribute_value(2, (*v3_AmbientIntensity)); } if (v4_Intensity) {set_attribute_value(3, (*v4_Intensity)); } }
|
|
|
|
// Function implementations for IfcLightSourceDirectional
|
|
::Ifc4::IfcDirection Ifc4::IfcLightSourceDirectional::Orientation() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcDirection>(); }
|
|
void Ifc4::IfcLightSourceDirectional::setOrientation(const ::Ifc4::IfcDirection& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLightSourceDirectional::Class() { return *((IfcParse::entity*)IFC4_types[530]); }
|
|
void Ifc4::IfcLightSourceDirectional::initialize(std::optional< std::string > v1_Name, ::Ifc4::IfcColourRgb v2_LightColour, std::optional< double > v3_AmbientIntensity, std::optional< double > v4_Intensity, ::Ifc4::IfcDirection v5_Orientation) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (v2_LightColour)); if (v3_AmbientIntensity) {set_attribute_value(2, (*v3_AmbientIntensity)); } if (v4_Intensity) {set_attribute_value(3, (*v4_Intensity)); }set_attribute_value(4, (v5_Orientation)); }
|
|
|
|
// Function implementations for IfcLightSourceGoniometric
|
|
::Ifc4::IfcAxis2Placement3D Ifc4::IfcLightSourceGoniometric::Position() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcAxis2Placement3D>(); }
|
|
void Ifc4::IfcLightSourceGoniometric::setPosition(const ::Ifc4::IfcAxis2Placement3D& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcColourRgb Ifc4::IfcLightSourceGoniometric::ColourAppearance() const { if(get_attribute_value(5).isNull()) { return ::Ifc4::IfcColourRgb{}; } return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcColourRgb>(); }
|
|
void Ifc4::IfcLightSourceGoniometric::setColourAppearance(const ::Ifc4::IfcColourRgb& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
double Ifc4::IfcLightSourceGoniometric::ColourTemperature() const { double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcLightSourceGoniometric::setColourTemperature(const double& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
double Ifc4::IfcLightSourceGoniometric::LuminousFlux() const { double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcLightSourceGoniometric::setLuminousFlux(const double& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
::Ifc4::IfcLightEmissionSourceEnum::Value Ifc4::IfcLightSourceGoniometric::LightEmissionSource() const { return ::Ifc4::IfcLightEmissionSourceEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcLightSourceGoniometric::setLightEmissionSource(const ::Ifc4::IfcLightEmissionSourceEnum::Value& v) { set_attribute_value(8, EnumerationReference(&::Ifc4::IfcLightEmissionSourceEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }
|
|
::Ifc4::IfcLightDistributionDataSourceSelect Ifc4::IfcLightSourceGoniometric::LightDistributionDataSource() const { return ((express::Base)(get_attribute_value(9))).as<::Ifc4::IfcLightDistributionDataSourceSelect>(); }
|
|
void Ifc4::IfcLightSourceGoniometric::setLightDistributionDataSource(const ::Ifc4::IfcLightDistributionDataSourceSelect& v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLightSourceGoniometric::Class() { return *((IfcParse::entity*)IFC4_types[531]); }
|
|
void Ifc4::IfcLightSourceGoniometric::initialize(std::optional< std::string > v1_Name, ::Ifc4::IfcColourRgb v2_LightColour, std::optional< double > v3_AmbientIntensity, std::optional< double > v4_Intensity, ::Ifc4::IfcAxis2Placement3D v5_Position, ::Ifc4::IfcColourRgb v6_ColourAppearance, double v7_ColourTemperature, double v8_LuminousFlux, ::Ifc4::IfcLightEmissionSourceEnum::Value v9_LightEmissionSource, ::Ifc4::IfcLightDistributionDataSourceSelect v10_LightDistributionDataSource) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (v2_LightColour)); if (v3_AmbientIntensity) {set_attribute_value(2, (*v3_AmbientIntensity)); } if (v4_Intensity) {set_attribute_value(3, (*v4_Intensity)); }set_attribute_value(4, (v5_Position));set_attribute_value(5, (v6_ColourAppearance));set_attribute_value(6, (v7_ColourTemperature));set_attribute_value(7, (v8_LuminousFlux));set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcLightEmissionSourceEnum::Class(),(size_t)v9_LightEmissionSource)));set_attribute_value(9, (v10_LightDistributionDataSource)); }
|
|
|
|
// Function implementations for IfcLightSourcePositional
|
|
::Ifc4::IfcCartesianPoint Ifc4::IfcLightSourcePositional::Position() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcCartesianPoint>(); }
|
|
void Ifc4::IfcLightSourcePositional::setPosition(const ::Ifc4::IfcCartesianPoint& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
double Ifc4::IfcLightSourcePositional::Radius() const { double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcLightSourcePositional::setRadius(const double& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
double Ifc4::IfcLightSourcePositional::ConstantAttenuation() const { double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcLightSourcePositional::setConstantAttenuation(const double& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
double Ifc4::IfcLightSourcePositional::DistanceAttenuation() const { double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcLightSourcePositional::setDistanceAttenuation(const double& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
double Ifc4::IfcLightSourcePositional::QuadricAttenuation() const { double v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcLightSourcePositional::setQuadricAttenuation(const double& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLightSourcePositional::Class() { return *((IfcParse::entity*)IFC4_types[532]); }
|
|
void Ifc4::IfcLightSourcePositional::initialize(std::optional< std::string > v1_Name, ::Ifc4::IfcColourRgb v2_LightColour, std::optional< double > v3_AmbientIntensity, std::optional< double > v4_Intensity, ::Ifc4::IfcCartesianPoint v5_Position, double v6_Radius, double v7_ConstantAttenuation, double v8_DistanceAttenuation, double v9_QuadricAttenuation) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (v2_LightColour)); if (v3_AmbientIntensity) {set_attribute_value(2, (*v3_AmbientIntensity)); } if (v4_Intensity) {set_attribute_value(3, (*v4_Intensity)); }set_attribute_value(4, (v5_Position));set_attribute_value(5, (v6_Radius));set_attribute_value(6, (v7_ConstantAttenuation));set_attribute_value(7, (v8_DistanceAttenuation));set_attribute_value(8, (v9_QuadricAttenuation)); }
|
|
|
|
// Function implementations for IfcLightSourceSpot
|
|
::Ifc4::IfcDirection Ifc4::IfcLightSourceSpot::Orientation() const { return ((express::Base)(get_attribute_value(9))).as<::Ifc4::IfcDirection>(); }
|
|
void Ifc4::IfcLightSourceSpot::setOrientation(const ::Ifc4::IfcDirection& v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }
|
|
std::optional< double > Ifc4::IfcLightSourceSpot::ConcentrationExponent() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } double v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcLightSourceSpot::setConcentrationExponent(const std::optional< double >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
double Ifc4::IfcLightSourceSpot::SpreadAngle() const { double v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcLightSourceSpot::setSpreadAngle(const double& v) { set_attribute_value(11, v);if constexpr (false)unset_attribute_value(11); }
|
|
double Ifc4::IfcLightSourceSpot::BeamWidthAngle() const { double v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcLightSourceSpot::setBeamWidthAngle(const double& v) { set_attribute_value(12, v);if constexpr (false)unset_attribute_value(12); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLightSourceSpot::Class() { return *((IfcParse::entity*)IFC4_types[533]); }
|
|
void Ifc4::IfcLightSourceSpot::initialize(std::optional< std::string > v1_Name, ::Ifc4::IfcColourRgb v2_LightColour, std::optional< double > v3_AmbientIntensity, std::optional< double > v4_Intensity, ::Ifc4::IfcCartesianPoint v5_Position, double v6_Radius, double v7_ConstantAttenuation, double v8_DistanceAttenuation, double v9_QuadricAttenuation, ::Ifc4::IfcDirection v10_Orientation, std::optional< double > v11_ConcentrationExponent, double v12_SpreadAngle, double v13_BeamWidthAngle) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (v2_LightColour)); if (v3_AmbientIntensity) {set_attribute_value(2, (*v3_AmbientIntensity)); } if (v4_Intensity) {set_attribute_value(3, (*v4_Intensity)); }set_attribute_value(4, (v5_Position));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)); if (v11_ConcentrationExponent) {set_attribute_value(10, (*v11_ConcentrationExponent)); }set_attribute_value(11, (v12_SpreadAngle));set_attribute_value(12, (v13_BeamWidthAngle)); }
|
|
|
|
// Function implementations for IfcLine
|
|
::Ifc4::IfcCartesianPoint Ifc4::IfcLine::Pnt() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcCartesianPoint>(); }
|
|
void Ifc4::IfcLine::setPnt(const ::Ifc4::IfcCartesianPoint& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcVector Ifc4::IfcLine::Dir() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcVector>(); }
|
|
void Ifc4::IfcLine::setDir(const ::Ifc4::IfcVector& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLine::Class() { return *((IfcParse::entity*)IFC4_types[534]); }
|
|
void Ifc4::IfcLine::initialize(::Ifc4::IfcCartesianPoint v1_Pnt, ::Ifc4::IfcVector v2_Dir) { set_attribute_value(0, (v1_Pnt));set_attribute_value(1, (v2_Dir)); }
|
|
|
|
// Function implementations for IfcLocalPlacement
|
|
::Ifc4::IfcObjectPlacement Ifc4::IfcLocalPlacement::PlacementRelTo() const { if(get_attribute_value(0).isNull()) { return ::Ifc4::IfcObjectPlacement{}; } return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcObjectPlacement>(); }
|
|
void Ifc4::IfcLocalPlacement::setPlacementRelTo(const ::Ifc4::IfcObjectPlacement& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcAxis2Placement Ifc4::IfcLocalPlacement::RelativePlacement() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcAxis2Placement>(); }
|
|
void Ifc4::IfcLocalPlacement::setRelativePlacement(const ::Ifc4::IfcAxis2Placement& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLocalPlacement::Class() { return *((IfcParse::entity*)IFC4_types[541]); }
|
|
void Ifc4::IfcLocalPlacement::initialize(::Ifc4::IfcObjectPlacement v1_PlacementRelTo, ::Ifc4::IfcAxis2Placement v2_RelativePlacement) { set_attribute_value(0, (v1_PlacementRelTo));set_attribute_value(1, (v2_RelativePlacement)); }
|
|
|
|
// Function implementations for IfcLoop
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcLoop::Class() { return *((IfcParse::entity*)IFC4_types[544]); }
|
|
void Ifc4::IfcLoop::initialize() { }
|
|
|
|
// Function implementations for IfcManifoldSolidBrep
|
|
::Ifc4::IfcClosedShell Ifc4::IfcManifoldSolidBrep::Outer() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcClosedShell>(); }
|
|
void Ifc4::IfcManifoldSolidBrep::setOuter(const ::Ifc4::IfcClosedShell& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcManifoldSolidBrep::Class() { return *((IfcParse::entity*)IFC4_types[551]); }
|
|
void Ifc4::IfcManifoldSolidBrep::initialize(::Ifc4::IfcClosedShell v1_Outer) { set_attribute_value(0, (v1_Outer)); }
|
|
|
|
// Function implementations for IfcMapConversion
|
|
double Ifc4::IfcMapConversion::Eastings() const { double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcMapConversion::setEastings(const double& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
double Ifc4::IfcMapConversion::Northings() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcMapConversion::setNorthings(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
double Ifc4::IfcMapConversion::OrthogonalHeight() const { double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcMapConversion::setOrthogonalHeight(const double& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
std::optional< double > Ifc4::IfcMapConversion::XAxisAbscissa() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcMapConversion::setXAxisAbscissa(const std::optional< double >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< double > Ifc4::IfcMapConversion::XAxisOrdinate() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcMapConversion::setXAxisOrdinate(const std::optional< double >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
std::optional< double > Ifc4::IfcMapConversion::Scale() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcMapConversion::setScale(const std::optional< double >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMapConversion::Class() { return *((IfcParse::entity*)IFC4_types[552]); }
|
|
void Ifc4::IfcMapConversion::initialize(::Ifc4::IfcCoordinateReferenceSystemSelect v1_SourceCRS, ::Ifc4::IfcCoordinateReferenceSystem v2_TargetCRS, double v3_Eastings, double v4_Northings, double v5_OrthogonalHeight, std::optional< double > v6_XAxisAbscissa, std::optional< double > v7_XAxisOrdinate, std::optional< double > v8_Scale) { set_attribute_value(0, (v1_SourceCRS));set_attribute_value(1, (v2_TargetCRS));set_attribute_value(2, (v3_Eastings));set_attribute_value(3, (v4_Northings));set_attribute_value(4, (v5_OrthogonalHeight)); if (v6_XAxisAbscissa) {set_attribute_value(5, (*v6_XAxisAbscissa)); } if (v7_XAxisOrdinate) {set_attribute_value(6, (*v7_XAxisOrdinate)); } if (v8_Scale) {set_attribute_value(7, (*v8_Scale)); } }
|
|
|
|
// Function implementations for IfcMappedItem
|
|
::Ifc4::IfcRepresentationMap Ifc4::IfcMappedItem::MappingSource() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcRepresentationMap>(); }
|
|
void Ifc4::IfcMappedItem::setMappingSource(const ::Ifc4::IfcRepresentationMap& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcCartesianTransformationOperator Ifc4::IfcMappedItem::MappingTarget() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcCartesianTransformationOperator>(); }
|
|
void Ifc4::IfcMappedItem::setMappingTarget(const ::Ifc4::IfcCartesianTransformationOperator& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMappedItem::Class() { return *((IfcParse::entity*)IFC4_types[553]); }
|
|
void Ifc4::IfcMappedItem::initialize(::Ifc4::IfcRepresentationMap v1_MappingSource, ::Ifc4::IfcCartesianTransformationOperator v2_MappingTarget) { set_attribute_value(0, (v1_MappingSource));set_attribute_value(1, (v2_MappingTarget)); }
|
|
|
|
// Function implementations for IfcMaterial
|
|
std::string Ifc4::IfcMaterial::Name() const { std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcMaterial::setName(const std::string& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< std::string > Ifc4::IfcMaterial::Description() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcMaterial::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< std::string > Ifc4::IfcMaterial::Category() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcMaterial::setCategory(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
|
|
std::vector<::Ifc4::IfcMaterialDefinitionRepresentation> Ifc4::IfcMaterial::HasRepresentation() const { return cast_vector<IfcMaterialDefinitionRepresentation>(file()->getInverse(data()->id(), IFC4_types[563], 3)); }
|
|
std::vector<::Ifc4::IfcMaterialRelationship> Ifc4::IfcMaterial::IsRelatedWith() const { return cast_vector<IfcMaterialRelationship>(file()->getInverse(data()->id(), IFC4_types[575], 3)); }
|
|
std::vector<::Ifc4::IfcMaterialRelationship> Ifc4::IfcMaterial::RelatesTo() const { return cast_vector<IfcMaterialRelationship>(file()->getInverse(data()->id(), IFC4_types[575], 2)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterial::Class() { return *((IfcParse::entity*)IFC4_types[558]); }
|
|
void Ifc4::IfcMaterial::initialize(std::string v1_Name, std::optional< std::string > v2_Description, std::optional< std::string > v3_Category) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); } if (v3_Category) {set_attribute_value(2, (*v3_Category)); } }
|
|
|
|
// Function implementations for IfcMaterialClassificationRelationship
|
|
std::vector< ::Ifc4::IfcClassificationSelect > Ifc4::IfcMaterialClassificationRelationship::MaterialClassifications() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcClassificationSelect>(es); }
|
|
void Ifc4::IfcMaterialClassificationRelationship::setMaterialClassifications(const std::vector< ::Ifc4::IfcClassificationSelect >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcMaterial Ifc4::IfcMaterialClassificationRelationship::ClassifiedMaterial() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcMaterial>(); }
|
|
void Ifc4::IfcMaterialClassificationRelationship::setClassifiedMaterial(const ::Ifc4::IfcMaterial& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialClassificationRelationship::Class() { return *((IfcParse::entity*)IFC4_types[559]); }
|
|
void Ifc4::IfcMaterialClassificationRelationship::initialize(std::vector< ::Ifc4::IfcClassificationSelect > v1_MaterialClassifications, ::Ifc4::IfcMaterial v2_ClassifiedMaterial) { set_attribute_value(0, cast_vector<express::Base>(v1_MaterialClassifications));set_attribute_value(1, (v2_ClassifiedMaterial)); }
|
|
|
|
// Function implementations for IfcMaterialConstituent
|
|
std::optional< std::string > Ifc4::IfcMaterialConstituent::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcMaterialConstituent::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< std::string > Ifc4::IfcMaterialConstituent::Description() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcMaterialConstituent::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
::Ifc4::IfcMaterial Ifc4::IfcMaterialConstituent::Material() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcMaterial>(); }
|
|
void Ifc4::IfcMaterialConstituent::setMaterial(const ::Ifc4::IfcMaterial& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
std::optional< double > Ifc4::IfcMaterialConstituent::Fraction() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcMaterialConstituent::setFraction(const std::optional< double >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< std::string > Ifc4::IfcMaterialConstituent::Category() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcMaterialConstituent::setCategory(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
std::vector<::Ifc4::IfcMaterialConstituentSet> Ifc4::IfcMaterialConstituent::ToMaterialConstituentSet() const { return cast_vector<IfcMaterialConstituentSet>(file()->getInverse(data()->id(), IFC4_types[561], 2)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialConstituent::Class() { return *((IfcParse::entity*)IFC4_types[560]); }
|
|
void Ifc4::IfcMaterialConstituent::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcMaterial v3_Material, std::optional< double > v4_Fraction, std::optional< std::string > v5_Category) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_Material)); if (v4_Fraction) {set_attribute_value(3, (*v4_Fraction)); } if (v5_Category) {set_attribute_value(4, (*v5_Category)); } }
|
|
|
|
// Function implementations for IfcMaterialConstituentSet
|
|
std::optional< std::string > Ifc4::IfcMaterialConstituentSet::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcMaterialConstituentSet::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< std::string > Ifc4::IfcMaterialConstituentSet::Description() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcMaterialConstituentSet::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< std::vector< ::Ifc4::IfcMaterialConstituent > > Ifc4::IfcMaterialConstituentSet::MaterialConstituents() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcMaterialConstituent>(es); }
|
|
void Ifc4::IfcMaterialConstituentSet::setMaterialConstituents(const std::optional< std::vector< ::Ifc4::IfcMaterialConstituent > >& v) { if (v) {set_attribute_value(2, cast_vector<express::Base>(*v));} else {unset_attribute_value(2);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialConstituentSet::Class() { return *((IfcParse::entity*)IFC4_types[561]); }
|
|
void Ifc4::IfcMaterialConstituentSet::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, std::optional< std::vector< ::Ifc4::IfcMaterialConstituent > > v3_MaterialConstituents) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); } if (v3_MaterialConstituents) {set_attribute_value(2, cast_vector<express::Base>(*v3_MaterialConstituents)); } }
|
|
|
|
// Function implementations for IfcMaterialDefinition
|
|
|
|
std::vector<::Ifc4::IfcRelAssociatesMaterial> Ifc4::IfcMaterialDefinition::AssociatedTo() const { return cast_vector<IfcRelAssociatesMaterial>(file()->getInverse(data()->id(), IFC4_types[812], 5)); }
|
|
std::vector<::Ifc4::IfcExternalReferenceRelationship> Ifc4::IfcMaterialDefinition::HasExternalReferences() const { return cast_vector<IfcExternalReferenceRelationship>(file()->getInverse(data()->id(), IFC4_types[380], 3)); }
|
|
std::vector<::Ifc4::IfcMaterialProperties> Ifc4::IfcMaterialDefinition::HasProperties() const { return cast_vector<IfcMaterialProperties>(file()->getInverse(data()->id(), IFC4_types[574], 3)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialDefinition::Class() { return *((IfcParse::entity*)IFC4_types[562]); }
|
|
void Ifc4::IfcMaterialDefinition::initialize() { }
|
|
|
|
// Function implementations for IfcMaterialDefinitionRepresentation
|
|
::Ifc4::IfcMaterial Ifc4::IfcMaterialDefinitionRepresentation::RepresentedMaterial() const { return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcMaterial>(); }
|
|
void Ifc4::IfcMaterialDefinitionRepresentation::setRepresentedMaterial(const ::Ifc4::IfcMaterial& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialDefinitionRepresentation::Class() { return *((IfcParse::entity*)IFC4_types[563]); }
|
|
void Ifc4::IfcMaterialDefinitionRepresentation::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, std::vector< ::Ifc4::IfcRepresentation > v3_Representations, ::Ifc4::IfcMaterial v4_RepresentedMaterial) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, cast_vector<express::Base>(v3_Representations));set_attribute_value(3, (v4_RepresentedMaterial)); }
|
|
|
|
// Function implementations for IfcMaterialLayer
|
|
::Ifc4::IfcMaterial Ifc4::IfcMaterialLayer::Material() const { if(get_attribute_value(0).isNull()) { return ::Ifc4::IfcMaterial{}; } return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcMaterial>(); }
|
|
void Ifc4::IfcMaterialLayer::setMaterial(const ::Ifc4::IfcMaterial& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
double Ifc4::IfcMaterialLayer::LayerThickness() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcMaterialLayer::setLayerThickness(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
std::optional< boost::logic::tribool > Ifc4::IfcMaterialLayer::IsVentilated() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } boost::logic::tribool v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcMaterialLayer::setIsVentilated(const std::optional< boost::logic::tribool >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< std::string > Ifc4::IfcMaterialLayer::Name() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcMaterialLayer::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< std::string > Ifc4::IfcMaterialLayer::Description() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcMaterialLayer::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcMaterialLayer::Category() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcMaterialLayer::setCategory(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< int > Ifc4::IfcMaterialLayer::Priority() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } int v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcMaterialLayer::setPriority(const std::optional< int >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
|
|
std::vector<::Ifc4::IfcMaterialLayerSet> Ifc4::IfcMaterialLayer::ToMaterialLayerSet() const { return cast_vector<IfcMaterialLayerSet>(file()->getInverse(data()->id(), IFC4_types[565], 0)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialLayer::Class() { return *((IfcParse::entity*)IFC4_types[564]); }
|
|
void Ifc4::IfcMaterialLayer::initialize(::Ifc4::IfcMaterial v1_Material, double v2_LayerThickness, std::optional< boost::logic::tribool > v3_IsVentilated, std::optional< std::string > v4_Name, std::optional< std::string > v5_Description, std::optional< std::string > v6_Category, std::optional< int > v7_Priority) { set_attribute_value(0, (v1_Material));set_attribute_value(1, (v2_LayerThickness)); if (v3_IsVentilated) {set_attribute_value(2, (*v3_IsVentilated)); } if (v4_Name) {set_attribute_value(3, (*v4_Name)); } if (v5_Description) {set_attribute_value(4, (*v5_Description)); } if (v6_Category) {set_attribute_value(5, (*v6_Category)); } if (v7_Priority) {set_attribute_value(6, (*v7_Priority)); } }
|
|
|
|
// Function implementations for IfcMaterialLayerSet
|
|
std::vector< ::Ifc4::IfcMaterialLayer > Ifc4::IfcMaterialLayerSet::MaterialLayers() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcMaterialLayer>(es); }
|
|
void Ifc4::IfcMaterialLayerSet::setMaterialLayers(const std::vector< ::Ifc4::IfcMaterialLayer >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< std::string > Ifc4::IfcMaterialLayerSet::LayerSetName() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcMaterialLayerSet::setLayerSetName(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< std::string > Ifc4::IfcMaterialLayerSet::Description() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcMaterialLayerSet::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialLayerSet::Class() { return *((IfcParse::entity*)IFC4_types[565]); }
|
|
void Ifc4::IfcMaterialLayerSet::initialize(std::vector< ::Ifc4::IfcMaterialLayer > v1_MaterialLayers, std::optional< std::string > v2_LayerSetName, std::optional< std::string > v3_Description) { set_attribute_value(0, cast_vector<express::Base>(v1_MaterialLayers)); if (v2_LayerSetName) {set_attribute_value(1, (*v2_LayerSetName)); } if (v3_Description) {set_attribute_value(2, (*v3_Description)); } }
|
|
|
|
// Function implementations for IfcMaterialLayerSetUsage
|
|
::Ifc4::IfcMaterialLayerSet Ifc4::IfcMaterialLayerSetUsage::ForLayerSet() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcMaterialLayerSet>(); }
|
|
void Ifc4::IfcMaterialLayerSetUsage::setForLayerSet(const ::Ifc4::IfcMaterialLayerSet& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcLayerSetDirectionEnum::Value Ifc4::IfcMaterialLayerSetUsage::LayerSetDirection() const { return ::Ifc4::IfcLayerSetDirectionEnum::FromString(get_attribute_value(1)); }
|
|
void Ifc4::IfcMaterialLayerSetUsage::setLayerSetDirection(const ::Ifc4::IfcLayerSetDirectionEnum::Value& v) { set_attribute_value(1, EnumerationReference(&::Ifc4::IfcLayerSetDirectionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcDirectionSenseEnum::Value Ifc4::IfcMaterialLayerSetUsage::DirectionSense() const { return ::Ifc4::IfcDirectionSenseEnum::FromString(get_attribute_value(2)); }
|
|
void Ifc4::IfcMaterialLayerSetUsage::setDirectionSense(const ::Ifc4::IfcDirectionSenseEnum::Value& v) { set_attribute_value(2, EnumerationReference(&::Ifc4::IfcDirectionSenseEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(2); }
|
|
double Ifc4::IfcMaterialLayerSetUsage::OffsetFromReferenceLine() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcMaterialLayerSetUsage::setOffsetFromReferenceLine(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< double > Ifc4::IfcMaterialLayerSetUsage::ReferenceExtent() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcMaterialLayerSetUsage::setReferenceExtent(const std::optional< double >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialLayerSetUsage::Class() { return *((IfcParse::entity*)IFC4_types[566]); }
|
|
void Ifc4::IfcMaterialLayerSetUsage::initialize(::Ifc4::IfcMaterialLayerSet v1_ForLayerSet, ::Ifc4::IfcLayerSetDirectionEnum::Value v2_LayerSetDirection, ::Ifc4::IfcDirectionSenseEnum::Value v3_DirectionSense, double v4_OffsetFromReferenceLine, std::optional< double > v5_ReferenceExtent) { set_attribute_value(0, (v1_ForLayerSet));set_attribute_value(1, (EnumerationReference(&::Ifc4::IfcLayerSetDirectionEnum::Class(),(size_t)v2_LayerSetDirection)));set_attribute_value(2, (EnumerationReference(&::Ifc4::IfcDirectionSenseEnum::Class(),(size_t)v3_DirectionSense)));set_attribute_value(3, (v4_OffsetFromReferenceLine)); if (v5_ReferenceExtent) {set_attribute_value(4, (*v5_ReferenceExtent)); } }
|
|
|
|
// Function implementations for IfcMaterialLayerWithOffsets
|
|
::Ifc4::IfcLayerSetDirectionEnum::Value Ifc4::IfcMaterialLayerWithOffsets::OffsetDirection() const { return ::Ifc4::IfcLayerSetDirectionEnum::FromString(get_attribute_value(7)); }
|
|
void Ifc4::IfcMaterialLayerWithOffsets::setOffsetDirection(const ::Ifc4::IfcLayerSetDirectionEnum::Value& v) { set_attribute_value(7, EnumerationReference(&::Ifc4::IfcLayerSetDirectionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }
|
|
std::vector< double > /*[1:2]*/ Ifc4::IfcMaterialLayerWithOffsets::OffsetValues() const { std::vector< double > /*[1:2]*/ v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcMaterialLayerWithOffsets::setOffsetValues(const std::vector< double > /*[1:2]*/& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialLayerWithOffsets::Class() { return *((IfcParse::entity*)IFC4_types[567]); }
|
|
void Ifc4::IfcMaterialLayerWithOffsets::initialize(::Ifc4::IfcMaterial v1_Material, double v2_LayerThickness, std::optional< boost::logic::tribool > v3_IsVentilated, std::optional< std::string > v4_Name, std::optional< std::string > v5_Description, std::optional< std::string > v6_Category, std::optional< int > v7_Priority, ::Ifc4::IfcLayerSetDirectionEnum::Value v8_OffsetDirection, std::vector< double > /*[1:2]*/ v9_OffsetValues) { set_attribute_value(0, (v1_Material));set_attribute_value(1, (v2_LayerThickness)); if (v3_IsVentilated) {set_attribute_value(2, (*v3_IsVentilated)); } if (v4_Name) {set_attribute_value(3, (*v4_Name)); } if (v5_Description) {set_attribute_value(4, (*v5_Description)); } if (v6_Category) {set_attribute_value(5, (*v6_Category)); } if (v7_Priority) {set_attribute_value(6, (*v7_Priority)); }set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcLayerSetDirectionEnum::Class(),(size_t)v8_OffsetDirection)));set_attribute_value(8, (v9_OffsetValues)); }
|
|
|
|
// Function implementations for IfcMaterialList
|
|
std::vector< ::Ifc4::IfcMaterial > Ifc4::IfcMaterialList::Materials() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcMaterial>(es); }
|
|
void Ifc4::IfcMaterialList::setMaterials(const std::vector< ::Ifc4::IfcMaterial >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialList::Class() { return *((IfcParse::entity*)IFC4_types[568]); }
|
|
void Ifc4::IfcMaterialList::initialize(std::vector< ::Ifc4::IfcMaterial > v1_Materials) { set_attribute_value(0, cast_vector<express::Base>(v1_Materials)); }
|
|
|
|
// Function implementations for IfcMaterialProfile
|
|
std::optional< std::string > Ifc4::IfcMaterialProfile::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcMaterialProfile::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< std::string > Ifc4::IfcMaterialProfile::Description() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcMaterialProfile::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
::Ifc4::IfcMaterial Ifc4::IfcMaterialProfile::Material() const { if(get_attribute_value(2).isNull()) { return ::Ifc4::IfcMaterial{}; } return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcMaterial>(); }
|
|
void Ifc4::IfcMaterialProfile::setMaterial(const ::Ifc4::IfcMaterial& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcProfileDef Ifc4::IfcMaterialProfile::Profile() const { return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcProfileDef>(); }
|
|
void Ifc4::IfcMaterialProfile::setProfile(const ::Ifc4::IfcProfileDef& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< int > Ifc4::IfcMaterialProfile::Priority() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } int v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcMaterialProfile::setPriority(const std::optional< int >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcMaterialProfile::Category() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcMaterialProfile::setCategory(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
|
|
std::vector<::Ifc4::IfcMaterialProfileSet> Ifc4::IfcMaterialProfile::ToMaterialProfileSet() const { return cast_vector<IfcMaterialProfileSet>(file()->getInverse(data()->id(), IFC4_types[570], 2)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialProfile::Class() { return *((IfcParse::entity*)IFC4_types[569]); }
|
|
void Ifc4::IfcMaterialProfile::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcMaterial v3_Material, ::Ifc4::IfcProfileDef v4_Profile, std::optional< int > v5_Priority, std::optional< std::string > v6_Category) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_Material));set_attribute_value(3, (v4_Profile)); if (v5_Priority) {set_attribute_value(4, (*v5_Priority)); } if (v6_Category) {set_attribute_value(5, (*v6_Category)); } }
|
|
|
|
// Function implementations for IfcMaterialProfileSet
|
|
std::optional< std::string > Ifc4::IfcMaterialProfileSet::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcMaterialProfileSet::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< std::string > Ifc4::IfcMaterialProfileSet::Description() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcMaterialProfileSet::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::vector< ::Ifc4::IfcMaterialProfile > Ifc4::IfcMaterialProfileSet::MaterialProfiles() const { std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcMaterialProfile>(es); }
|
|
void Ifc4::IfcMaterialProfileSet::setMaterialProfiles(const std::vector< ::Ifc4::IfcMaterialProfile >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcCompositeProfileDef Ifc4::IfcMaterialProfileSet::CompositeProfile() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcCompositeProfileDef{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcCompositeProfileDef>(); }
|
|
void Ifc4::IfcMaterialProfileSet::setCompositeProfile(const ::Ifc4::IfcCompositeProfileDef& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialProfileSet::Class() { return *((IfcParse::entity*)IFC4_types[570]); }
|
|
void Ifc4::IfcMaterialProfileSet::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, std::vector< ::Ifc4::IfcMaterialProfile > v3_MaterialProfiles, ::Ifc4::IfcCompositeProfileDef v4_CompositeProfile) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, cast_vector<express::Base>(v3_MaterialProfiles));set_attribute_value(3, (v4_CompositeProfile)); }
|
|
|
|
// Function implementations for IfcMaterialProfileSetUsage
|
|
::Ifc4::IfcMaterialProfileSet Ifc4::IfcMaterialProfileSetUsage::ForProfileSet() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcMaterialProfileSet>(); }
|
|
void Ifc4::IfcMaterialProfileSetUsage::setForProfileSet(const ::Ifc4::IfcMaterialProfileSet& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< int > Ifc4::IfcMaterialProfileSetUsage::CardinalPoint() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } int v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcMaterialProfileSetUsage::setCardinalPoint(const std::optional< int >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< double > Ifc4::IfcMaterialProfileSetUsage::ReferenceExtent() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcMaterialProfileSetUsage::setReferenceExtent(const std::optional< double >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialProfileSetUsage::Class() { return *((IfcParse::entity*)IFC4_types[571]); }
|
|
void Ifc4::IfcMaterialProfileSetUsage::initialize(::Ifc4::IfcMaterialProfileSet v1_ForProfileSet, std::optional< int > v2_CardinalPoint, std::optional< double > v3_ReferenceExtent) { set_attribute_value(0, (v1_ForProfileSet)); if (v2_CardinalPoint) {set_attribute_value(1, (*v2_CardinalPoint)); } if (v3_ReferenceExtent) {set_attribute_value(2, (*v3_ReferenceExtent)); } }
|
|
|
|
// Function implementations for IfcMaterialProfileSetUsageTapering
|
|
::Ifc4::IfcMaterialProfileSet Ifc4::IfcMaterialProfileSetUsageTapering::ForProfileEndSet() const { return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcMaterialProfileSet>(); }
|
|
void Ifc4::IfcMaterialProfileSetUsageTapering::setForProfileEndSet(const ::Ifc4::IfcMaterialProfileSet& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< int > Ifc4::IfcMaterialProfileSetUsageTapering::CardinalEndPoint() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } int v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcMaterialProfileSetUsageTapering::setCardinalEndPoint(const std::optional< int >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialProfileSetUsageTapering::Class() { return *((IfcParse::entity*)IFC4_types[572]); }
|
|
void Ifc4::IfcMaterialProfileSetUsageTapering::initialize(::Ifc4::IfcMaterialProfileSet v1_ForProfileSet, std::optional< int > v2_CardinalPoint, std::optional< double > v3_ReferenceExtent, ::Ifc4::IfcMaterialProfileSet v4_ForProfileEndSet, std::optional< int > v5_CardinalEndPoint) { set_attribute_value(0, (v1_ForProfileSet)); if (v2_CardinalPoint) {set_attribute_value(1, (*v2_CardinalPoint)); } if (v3_ReferenceExtent) {set_attribute_value(2, (*v3_ReferenceExtent)); }set_attribute_value(3, (v4_ForProfileEndSet)); if (v5_CardinalEndPoint) {set_attribute_value(4, (*v5_CardinalEndPoint)); } }
|
|
|
|
// Function implementations for IfcMaterialProfileWithOffsets
|
|
std::vector< double > /*[1:2]*/ Ifc4::IfcMaterialProfileWithOffsets::OffsetValues() const { std::vector< double > /*[1:2]*/ v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcMaterialProfileWithOffsets::setOffsetValues(const std::vector< double > /*[1:2]*/& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialProfileWithOffsets::Class() { return *((IfcParse::entity*)IFC4_types[573]); }
|
|
void Ifc4::IfcMaterialProfileWithOffsets::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcMaterial v3_Material, ::Ifc4::IfcProfileDef v4_Profile, std::optional< int > v5_Priority, std::optional< std::string > v6_Category, std::vector< double > /*[1:2]*/ v7_OffsetValues) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_Material));set_attribute_value(3, (v4_Profile)); if (v5_Priority) {set_attribute_value(4, (*v5_Priority)); } if (v6_Category) {set_attribute_value(5, (*v6_Category)); }set_attribute_value(6, (v7_OffsetValues)); }
|
|
|
|
// Function implementations for IfcMaterialProperties
|
|
::Ifc4::IfcMaterialDefinition Ifc4::IfcMaterialProperties::Material() const { return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcMaterialDefinition>(); }
|
|
void Ifc4::IfcMaterialProperties::setMaterial(const ::Ifc4::IfcMaterialDefinition& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialProperties::Class() { return *((IfcParse::entity*)IFC4_types[574]); }
|
|
void Ifc4::IfcMaterialProperties::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, std::vector< ::Ifc4::IfcProperty > v3_Properties, ::Ifc4::IfcMaterialDefinition v4_Material) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, cast_vector<express::Base>(v3_Properties));set_attribute_value(3, (v4_Material)); }
|
|
|
|
// Function implementations for IfcMaterialRelationship
|
|
::Ifc4::IfcMaterial Ifc4::IfcMaterialRelationship::RelatingMaterial() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcMaterial>(); }
|
|
void Ifc4::IfcMaterialRelationship::setRelatingMaterial(const ::Ifc4::IfcMaterial& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
std::vector< ::Ifc4::IfcMaterial > Ifc4::IfcMaterialRelationship::RelatedMaterials() const { std::vector<express::Base> es = get_attribute_value(3); return cast_vector<::Ifc4::IfcMaterial>(es); }
|
|
void Ifc4::IfcMaterialRelationship::setRelatedMaterials(const std::vector< ::Ifc4::IfcMaterial >& v) { set_attribute_value(3, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< std::string > Ifc4::IfcMaterialRelationship::Expression() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcMaterialRelationship::setExpression(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialRelationship::Class() { return *((IfcParse::entity*)IFC4_types[575]); }
|
|
void Ifc4::IfcMaterialRelationship::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcMaterial v3_RelatingMaterial, std::vector< ::Ifc4::IfcMaterial > v4_RelatedMaterials, std::optional< std::string > v5_Expression) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_RelatingMaterial));set_attribute_value(3, cast_vector<express::Base>(v4_RelatedMaterials)); if (v5_Expression) {set_attribute_value(4, (*v5_Expression)); } }
|
|
|
|
// Function implementations for IfcMaterialUsageDefinition
|
|
|
|
std::vector<::Ifc4::IfcRelAssociatesMaterial> Ifc4::IfcMaterialUsageDefinition::AssociatedTo() const { return cast_vector<IfcRelAssociatesMaterial>(file()->getInverse(data()->id(), IFC4_types[812], 5)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcMaterialUsageDefinition::Class() { return *((IfcParse::entity*)IFC4_types[577]); }
|
|
void Ifc4::IfcMaterialUsageDefinition::initialize() { }
|
|
|
|
// Function implementations for IfcMeasureWithUnit
|
|
::Ifc4::IfcValue Ifc4::IfcMeasureWithUnit::ValueComponent() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcValue>(); }
|
|
void Ifc4::IfcMeasureWithUnit::setValueComponent(const ::Ifc4::IfcValue& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcUnit Ifc4::IfcMeasureWithUnit::UnitComponent() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcUnit>(); }
|
|
void Ifc4::IfcMeasureWithUnit::setUnitComponent(const ::Ifc4::IfcUnit& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMeasureWithUnit::Class() { return *((IfcParse::entity*)IFC4_types[579]); }
|
|
void Ifc4::IfcMeasureWithUnit::initialize(::Ifc4::IfcValue v1_ValueComponent, ::Ifc4::IfcUnit v2_UnitComponent) { set_attribute_value(0, (v1_ValueComponent));set_attribute_value(1, (v2_UnitComponent)); }
|
|
|
|
// Function implementations for IfcMechanicalFastener
|
|
std::optional< double > Ifc4::IfcMechanicalFastener::NominalDiameter() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } double v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcMechanicalFastener::setNominalDiameter(const std::optional< double >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
std::optional< double > Ifc4::IfcMechanicalFastener::NominalLength() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } double v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcMechanicalFastener::setNominalLength(const std::optional< double >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
std::optional< ::Ifc4::IfcMechanicalFastenerTypeEnum::Value > Ifc4::IfcMechanicalFastener::PredefinedType() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } return ::Ifc4::IfcMechanicalFastenerTypeEnum::FromString(get_attribute_value(10)); }
|
|
void Ifc4::IfcMechanicalFastener::setPredefinedType(const std::optional< ::Ifc4::IfcMechanicalFastenerTypeEnum::Value >& v) { if (v) {set_attribute_value(10, EnumerationReference(&::Ifc4::IfcMechanicalFastenerTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(10);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMechanicalFastener::Class() { return *((IfcParse::entity*)IFC4_types[580]); }
|
|
void Ifc4::IfcMechanicalFastener::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< double > v9_NominalDiameter, std::optional< double > v10_NominalLength, std::optional< ::Ifc4::IfcMechanicalFastenerTypeEnum::Value > v11_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); 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)); } if (v11_PredefinedType) {set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcMechanicalFastenerTypeEnum::Class(),(size_t)*v11_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcMechanicalFastenerType
|
|
::Ifc4::IfcMechanicalFastenerTypeEnum::Value Ifc4::IfcMechanicalFastenerType::PredefinedType() const { return ::Ifc4::IfcMechanicalFastenerTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcMechanicalFastenerType::setPredefinedType(const ::Ifc4::IfcMechanicalFastenerTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcMechanicalFastenerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
std::optional< double > Ifc4::IfcMechanicalFastenerType::NominalDiameter() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } double v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcMechanicalFastenerType::setNominalDiameter(const std::optional< double >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::optional< double > Ifc4::IfcMechanicalFastenerType::NominalLength() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } double v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcMechanicalFastenerType::setNominalLength(const std::optional< double >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMechanicalFastenerType::Class() { return *((IfcParse::entity*)IFC4_types[581]); }
|
|
void Ifc4::IfcMechanicalFastenerType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcMechanicalFastenerTypeEnum::Value v10_PredefinedType, std::optional< double > v11_NominalDiameter, std::optional< double > v12_NominalLength) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcMechanicalFastenerTypeEnum::Class(),(size_t)v10_PredefinedType))); if (v11_NominalDiameter) {set_attribute_value(10, (*v11_NominalDiameter)); } if (v12_NominalLength) {set_attribute_value(11, (*v12_NominalLength)); } }
|
|
|
|
// Function implementations for IfcMedicalDevice
|
|
std::optional< ::Ifc4::IfcMedicalDeviceTypeEnum::Value > Ifc4::IfcMedicalDevice::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcMedicalDeviceTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcMedicalDevice::setPredefinedType(const std::optional< ::Ifc4::IfcMedicalDeviceTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcMedicalDeviceTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMedicalDevice::Class() { return *((IfcParse::entity*)IFC4_types[583]); }
|
|
void Ifc4::IfcMedicalDevice::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcMedicalDeviceTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcMedicalDeviceTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcMedicalDeviceType
|
|
::Ifc4::IfcMedicalDeviceTypeEnum::Value Ifc4::IfcMedicalDeviceType::PredefinedType() const { return ::Ifc4::IfcMedicalDeviceTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcMedicalDeviceType::setPredefinedType(const ::Ifc4::IfcMedicalDeviceTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcMedicalDeviceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMedicalDeviceType::Class() { return *((IfcParse::entity*)IFC4_types[584]); }
|
|
void Ifc4::IfcMedicalDeviceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcMedicalDeviceTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcMedicalDeviceTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcMember
|
|
std::optional< ::Ifc4::IfcMemberTypeEnum::Value > Ifc4::IfcMember::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcMemberTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcMember::setPredefinedType(const std::optional< ::Ifc4::IfcMemberTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcMemberTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMember::Class() { return *((IfcParse::entity*)IFC4_types[586]); }
|
|
void Ifc4::IfcMember::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcMemberTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcMemberTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcMemberStandardCase
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMemberStandardCase::Class() { return *((IfcParse::entity*)IFC4_types[587]); }
|
|
void Ifc4::IfcMemberStandardCase::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcMemberTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcMemberTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcMemberType
|
|
::Ifc4::IfcMemberTypeEnum::Value Ifc4::IfcMemberType::PredefinedType() const { return ::Ifc4::IfcMemberTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcMemberType::setPredefinedType(const ::Ifc4::IfcMemberTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcMemberTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMemberType::Class() { return *((IfcParse::entity*)IFC4_types[588]); }
|
|
void Ifc4::IfcMemberType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcMemberTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcMemberTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcMetric
|
|
::Ifc4::IfcBenchmarkEnum::Value Ifc4::IfcMetric::Benchmark() const { return ::Ifc4::IfcBenchmarkEnum::FromString(get_attribute_value(7)); }
|
|
void Ifc4::IfcMetric::setBenchmark(const ::Ifc4::IfcBenchmarkEnum::Value& v) { set_attribute_value(7, EnumerationReference(&::Ifc4::IfcBenchmarkEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }
|
|
std::optional< std::string > Ifc4::IfcMetric::ValueSource() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcMetric::setValueSource(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
::Ifc4::IfcMetricValueSelect Ifc4::IfcMetric::DataValue() const { if(get_attribute_value(9).isNull()) { return ::Ifc4::IfcMetricValueSelect{}; } return ((express::Base)(get_attribute_value(9))).as<::Ifc4::IfcMetricValueSelect>(); }
|
|
void Ifc4::IfcMetric::setDataValue(const ::Ifc4::IfcMetricValueSelect& v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }
|
|
::Ifc4::IfcReference Ifc4::IfcMetric::ReferencePath() const { if(get_attribute_value(10).isNull()) { return ::Ifc4::IfcReference{}; } return ((express::Base)(get_attribute_value(10))).as<::Ifc4::IfcReference>(); }
|
|
void Ifc4::IfcMetric::setReferencePath(const ::Ifc4::IfcReference& v) { set_attribute_value(10, v);if constexpr (false)unset_attribute_value(10); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMetric::Class() { return *((IfcParse::entity*)IFC4_types[590]); }
|
|
void Ifc4::IfcMetric::initialize(std::string v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcConstraintEnum::Value v3_ConstraintGrade, std::optional< std::string > v4_ConstraintSource, ::Ifc4::IfcActorSelect v5_CreatingActor, std::optional< std::string > v6_CreationTime, std::optional< std::string > v7_UserDefinedGrade, ::Ifc4::IfcBenchmarkEnum::Value v8_Benchmark, std::optional< std::string > v9_ValueSource, ::Ifc4::IfcMetricValueSelect v10_DataValue, ::Ifc4::IfcReference v11_ReferencePath) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (EnumerationReference(&::Ifc4::IfcConstraintEnum::Class(),(size_t)v3_ConstraintGrade))); if (v4_ConstraintSource) {set_attribute_value(3, (*v4_ConstraintSource)); }set_attribute_value(4, (v5_CreatingActor)); if (v6_CreationTime) {set_attribute_value(5, (*v6_CreationTime)); } if (v7_UserDefinedGrade) {set_attribute_value(6, (*v7_UserDefinedGrade)); }set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcBenchmarkEnum::Class(),(size_t)v8_Benchmark))); if (v9_ValueSource) {set_attribute_value(8, (*v9_ValueSource)); }set_attribute_value(9, (v10_DataValue));set_attribute_value(10, (v11_ReferencePath)); }
|
|
|
|
// Function implementations for IfcMirroredProfileDef
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMirroredProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[592]); }
|
|
void Ifc4::IfcMirroredProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcProfileDef v3_ParentProfile, std::optional< std::string > v5_Label) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_ParentProfile)); if (v5_Label) {set_attribute_value(4, (*v5_Label)); } }
|
|
|
|
// Function implementations for IfcMonetaryUnit
|
|
std::string Ifc4::IfcMonetaryUnit::Currency() const { std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcMonetaryUnit::setCurrency(const std::string& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMonetaryUnit::Class() { return *((IfcParse::entity*)IFC4_types[604]); }
|
|
void Ifc4::IfcMonetaryUnit::initialize(std::string v1_Currency) { set_attribute_value(0, (v1_Currency)); }
|
|
|
|
// Function implementations for IfcMotorConnection
|
|
std::optional< ::Ifc4::IfcMotorConnectionTypeEnum::Value > Ifc4::IfcMotorConnection::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcMotorConnectionTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcMotorConnection::setPredefinedType(const std::optional< ::Ifc4::IfcMotorConnectionTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcMotorConnectionTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMotorConnection::Class() { return *((IfcParse::entity*)IFC4_types[606]); }
|
|
void Ifc4::IfcMotorConnection::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcMotorConnectionTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcMotorConnectionTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcMotorConnectionType
|
|
::Ifc4::IfcMotorConnectionTypeEnum::Value Ifc4::IfcMotorConnectionType::PredefinedType() const { return ::Ifc4::IfcMotorConnectionTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcMotorConnectionType::setPredefinedType(const ::Ifc4::IfcMotorConnectionTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcMotorConnectionTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcMotorConnectionType::Class() { return *((IfcParse::entity*)IFC4_types[607]); }
|
|
void Ifc4::IfcMotorConnectionType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcMotorConnectionTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcMotorConnectionTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcNamedUnit
|
|
::Ifc4::IfcDimensionalExponents Ifc4::IfcNamedUnit::Dimensions() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcDimensionalExponents>(); }
|
|
void Ifc4::IfcNamedUnit::setDimensions(const ::Ifc4::IfcDimensionalExponents& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcUnitEnum::Value Ifc4::IfcNamedUnit::UnitType() const { return ::Ifc4::IfcUnitEnum::FromString(get_attribute_value(1)); }
|
|
void Ifc4::IfcNamedUnit::setUnitType(const ::Ifc4::IfcUnitEnum::Value& v) { set_attribute_value(1, EnumerationReference(&::Ifc4::IfcUnitEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcNamedUnit::Class() { return *((IfcParse::entity*)IFC4_types[609]); }
|
|
void Ifc4::IfcNamedUnit::initialize(::Ifc4::IfcDimensionalExponents v1_Dimensions, ::Ifc4::IfcUnitEnum::Value v2_UnitType) { set_attribute_value(0, (v1_Dimensions));set_attribute_value(1, (EnumerationReference(&::Ifc4::IfcUnitEnum::Class(),(size_t)v2_UnitType))); }
|
|
|
|
// Function implementations for IfcObject
|
|
std::optional< std::string > Ifc4::IfcObject::ObjectType() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcObject::setObjectType(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
std::vector<::Ifc4::IfcRelDefinesByObject> Ifc4::IfcObject::IsDeclaredBy() const { return cast_vector<IfcRelDefinesByObject>(file()->getInverse(data()->id(), IFC4_types[829], 4)); }
|
|
std::vector<::Ifc4::IfcRelDefinesByObject> Ifc4::IfcObject::Declares() const { return cast_vector<IfcRelDefinesByObject>(file()->getInverse(data()->id(), IFC4_types[829], 5)); }
|
|
std::vector<::Ifc4::IfcRelDefinesByType> Ifc4::IfcObject::IsTypedBy() const { return cast_vector<IfcRelDefinesByType>(file()->getInverse(data()->id(), IFC4_types[832], 4)); }
|
|
std::vector<::Ifc4::IfcRelDefinesByProperties> Ifc4::IfcObject::IsDefinedBy() const { return cast_vector<IfcRelDefinesByProperties>(file()->getInverse(data()->id(), IFC4_types[830], 4)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcObject::Class() { return *((IfcParse::entity*)IFC4_types[614]); }
|
|
void Ifc4::IfcObject::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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)); } }
|
|
|
|
// Function implementations for IfcObjectDefinition
|
|
|
|
std::vector<::Ifc4::IfcRelAssigns> Ifc4::IfcObjectDefinition::HasAssignments() const { return cast_vector<IfcRelAssigns>(file()->getInverse(data()->id(), IFC4_types[798], 4)); }
|
|
std::vector<::Ifc4::IfcRelNests> Ifc4::IfcObjectDefinition::Nests() const { return cast_vector<IfcRelNests>(file()->getInverse(data()->id(), IFC4_types[836], 5)); }
|
|
std::vector<::Ifc4::IfcRelNests> Ifc4::IfcObjectDefinition::IsNestedBy() const { return cast_vector<IfcRelNests>(file()->getInverse(data()->id(), IFC4_types[836], 4)); }
|
|
std::vector<::Ifc4::IfcRelDeclares> Ifc4::IfcObjectDefinition::HasContext() const { return cast_vector<IfcRelDeclares>(file()->getInverse(data()->id(), IFC4_types[826], 5)); }
|
|
std::vector<::Ifc4::IfcRelAggregates> Ifc4::IfcObjectDefinition::IsDecomposedBy() const { return cast_vector<IfcRelAggregates>(file()->getInverse(data()->id(), IFC4_types[797], 4)); }
|
|
std::vector<::Ifc4::IfcRelAggregates> Ifc4::IfcObjectDefinition::Decomposes() const { return cast_vector<IfcRelAggregates>(file()->getInverse(data()->id(), IFC4_types[797], 5)); }
|
|
std::vector<::Ifc4::IfcRelAssociates> Ifc4::IfcObjectDefinition::HasAssociations() const { return cast_vector<IfcRelAssociates>(file()->getInverse(data()->id(), IFC4_types[806], 4)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcObjectDefinition::Class() { return *((IfcParse::entity*)IFC4_types[615]); }
|
|
void Ifc4::IfcObjectDefinition::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } }
|
|
|
|
// Function implementations for IfcObjectPlacement
|
|
|
|
std::vector<::Ifc4::IfcProduct> Ifc4::IfcObjectPlacement::PlacesObject() const { return cast_vector<IfcProduct>(file()->getInverse(data()->id(), IFC4_types[710], 5)); }
|
|
std::vector<::Ifc4::IfcLocalPlacement> Ifc4::IfcObjectPlacement::ReferencedByPlacements() const { return cast_vector<IfcLocalPlacement>(file()->getInverse(data()->id(), IFC4_types[541], 0)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcObjectPlacement::Class() { return *((IfcParse::entity*)IFC4_types[618]); }
|
|
void Ifc4::IfcObjectPlacement::initialize() { }
|
|
|
|
// Function implementations for IfcObjective
|
|
std::optional< std::vector< ::Ifc4::IfcConstraint > > Ifc4::IfcObjective::BenchmarkValues() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(7); return cast_vector<::Ifc4::IfcConstraint>(es); }
|
|
void Ifc4::IfcObjective::setBenchmarkValues(const std::optional< std::vector< ::Ifc4::IfcConstraint > >& v) { if (v) {set_attribute_value(7, cast_vector<express::Base>(*v));} else {unset_attribute_value(7);} }
|
|
std::optional< ::Ifc4::IfcLogicalOperatorEnum::Value > Ifc4::IfcObjective::LogicalAggregator() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcLogicalOperatorEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcObjective::setLogicalAggregator(const std::optional< ::Ifc4::IfcLogicalOperatorEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcLogicalOperatorEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
::Ifc4::IfcObjectiveEnum::Value Ifc4::IfcObjective::ObjectiveQualifier() const { return ::Ifc4::IfcObjectiveEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcObjective::setObjectiveQualifier(const ::Ifc4::IfcObjectiveEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcObjectiveEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
std::optional< std::string > Ifc4::IfcObjective::UserDefinedQualifier() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } std::string v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcObjective::setUserDefinedQualifier(const std::optional< std::string >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcObjective::Class() { return *((IfcParse::entity*)IFC4_types[616]); }
|
|
void Ifc4::IfcObjective::initialize(std::string v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcConstraintEnum::Value v3_ConstraintGrade, std::optional< std::string > v4_ConstraintSource, ::Ifc4::IfcActorSelect v5_CreatingActor, std::optional< std::string > v6_CreationTime, std::optional< std::string > v7_UserDefinedGrade, std::optional< std::vector< ::Ifc4::IfcConstraint > > v8_BenchmarkValues, std::optional< ::Ifc4::IfcLogicalOperatorEnum::Value > v9_LogicalAggregator, ::Ifc4::IfcObjectiveEnum::Value v10_ObjectiveQualifier, std::optional< std::string > v11_UserDefinedQualifier) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (EnumerationReference(&::Ifc4::IfcConstraintEnum::Class(),(size_t)v3_ConstraintGrade))); if (v4_ConstraintSource) {set_attribute_value(3, (*v4_ConstraintSource)); }set_attribute_value(4, (v5_CreatingActor)); if (v6_CreationTime) {set_attribute_value(5, (*v6_CreationTime)); } if (v7_UserDefinedGrade) {set_attribute_value(6, (*v7_UserDefinedGrade)); } if (v8_BenchmarkValues) {set_attribute_value(7, cast_vector<express::Base>(*v8_BenchmarkValues)); } if (v9_LogicalAggregator) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcLogicalOperatorEnum::Class(),(size_t)*v9_LogicalAggregator))); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcObjectiveEnum::Class(),(size_t)v10_ObjectiveQualifier))); if (v11_UserDefinedQualifier) {set_attribute_value(10, (*v11_UserDefinedQualifier)); } }
|
|
|
|
// Function implementations for IfcOccupant
|
|
std::optional< ::Ifc4::IfcOccupantTypeEnum::Value > Ifc4::IfcOccupant::PredefinedType() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } return ::Ifc4::IfcOccupantTypeEnum::FromString(get_attribute_value(6)); }
|
|
void Ifc4::IfcOccupant::setPredefinedType(const std::optional< ::Ifc4::IfcOccupantTypeEnum::Value >& v) { if (v) {set_attribute_value(6, EnumerationReference(&::Ifc4::IfcOccupantTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(6);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcOccupant::Class() { return *((IfcParse::entity*)IFC4_types[621]); }
|
|
void Ifc4::IfcOccupant::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcActorSelect v6_TheActor, std::optional< ::Ifc4::IfcOccupantTypeEnum::Value > v7_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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)); if (v7_PredefinedType) {set_attribute_value(6, (EnumerationReference(&::Ifc4::IfcOccupantTypeEnum::Class(),(size_t)*v7_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcOffsetCurve2D
|
|
::Ifc4::IfcCurve Ifc4::IfcOffsetCurve2D::BasisCurve() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcCurve>(); }
|
|
void Ifc4::IfcOffsetCurve2D::setBasisCurve(const ::Ifc4::IfcCurve& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
double Ifc4::IfcOffsetCurve2D::Distance() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcOffsetCurve2D::setDistance(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
boost::logic::tribool Ifc4::IfcOffsetCurve2D::SelfIntersect() const { boost::logic::tribool v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcOffsetCurve2D::setSelfIntersect(const boost::logic::tribool& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcOffsetCurve2D::Class() { return *((IfcParse::entity*)IFC4_types[623]); }
|
|
void Ifc4::IfcOffsetCurve2D::initialize(::Ifc4::IfcCurve v1_BasisCurve, double v2_Distance, boost::logic::tribool v3_SelfIntersect) { set_attribute_value(0, (v1_BasisCurve));set_attribute_value(1, (v2_Distance));set_attribute_value(2, (v3_SelfIntersect)); }
|
|
|
|
// Function implementations for IfcOffsetCurve3D
|
|
::Ifc4::IfcCurve Ifc4::IfcOffsetCurve3D::BasisCurve() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcCurve>(); }
|
|
void Ifc4::IfcOffsetCurve3D::setBasisCurve(const ::Ifc4::IfcCurve& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
double Ifc4::IfcOffsetCurve3D::Distance() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcOffsetCurve3D::setDistance(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
boost::logic::tribool Ifc4::IfcOffsetCurve3D::SelfIntersect() const { boost::logic::tribool v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcOffsetCurve3D::setSelfIntersect(const boost::logic::tribool& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcDirection Ifc4::IfcOffsetCurve3D::RefDirection() const { return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcDirection>(); }
|
|
void Ifc4::IfcOffsetCurve3D::setRefDirection(const ::Ifc4::IfcDirection& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcOffsetCurve3D::Class() { return *((IfcParse::entity*)IFC4_types[624]); }
|
|
void Ifc4::IfcOffsetCurve3D::initialize(::Ifc4::IfcCurve v1_BasisCurve, double v2_Distance, boost::logic::tribool v3_SelfIntersect, ::Ifc4::IfcDirection v4_RefDirection) { set_attribute_value(0, (v1_BasisCurve));set_attribute_value(1, (v2_Distance));set_attribute_value(2, (v3_SelfIntersect));set_attribute_value(3, (v4_RefDirection)); }
|
|
|
|
// Function implementations for IfcOpenShell
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcOpenShell::Class() { return *((IfcParse::entity*)IFC4_types[628]); }
|
|
void Ifc4::IfcOpenShell::initialize(std::vector< ::Ifc4::IfcFace > v1_CfsFaces) { set_attribute_value(0, cast_vector<express::Base>(v1_CfsFaces)); }
|
|
|
|
// Function implementations for IfcOpeningElement
|
|
std::optional< ::Ifc4::IfcOpeningElementTypeEnum::Value > Ifc4::IfcOpeningElement::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcOpeningElementTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcOpeningElement::setPredefinedType(const std::optional< ::Ifc4::IfcOpeningElementTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcOpeningElementTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
std::vector<::Ifc4::IfcRelFillsElement> Ifc4::IfcOpeningElement::HasFillings() const { return cast_vector<IfcRelFillsElement>(file()->getInverse(data()->id(), IFC4_types[833], 4)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcOpeningElement::Class() { return *((IfcParse::entity*)IFC4_types[625]); }
|
|
void Ifc4::IfcOpeningElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcOpeningElementTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcOpeningElementTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcOpeningStandardCase
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcOpeningStandardCase::Class() { return *((IfcParse::entity*)IFC4_types[627]); }
|
|
void Ifc4::IfcOpeningStandardCase::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcOpeningElementTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcOpeningElementTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcOrganization
|
|
std::optional< std::string > Ifc4::IfcOrganization::Identification() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcOrganization::setIdentification(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::string Ifc4::IfcOrganization::Name() const { std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcOrganization::setName(const std::string& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
std::optional< std::string > Ifc4::IfcOrganization::Description() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcOrganization::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< std::vector< ::Ifc4::IfcActorRole > > Ifc4::IfcOrganization::Roles() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(3); return cast_vector<::Ifc4::IfcActorRole>(es); }
|
|
void Ifc4::IfcOrganization::setRoles(const std::optional< std::vector< ::Ifc4::IfcActorRole > >& v) { if (v) {set_attribute_value(3, cast_vector<express::Base>(*v));} else {unset_attribute_value(3);} }
|
|
std::optional< std::vector< ::Ifc4::IfcAddress > > Ifc4::IfcOrganization::Addresses() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(4); return cast_vector<::Ifc4::IfcAddress>(es); }
|
|
void Ifc4::IfcOrganization::setAddresses(const std::optional< std::vector< ::Ifc4::IfcAddress > >& v) { if (v) {set_attribute_value(4, cast_vector<express::Base>(*v));} else {unset_attribute_value(4);} }
|
|
|
|
std::vector<::Ifc4::IfcOrganizationRelationship> Ifc4::IfcOrganization::IsRelatedBy() const { return cast_vector<IfcOrganizationRelationship>(file()->getInverse(data()->id(), IFC4_types[630], 3)); }
|
|
std::vector<::Ifc4::IfcOrganizationRelationship> Ifc4::IfcOrganization::Relates() const { return cast_vector<IfcOrganizationRelationship>(file()->getInverse(data()->id(), IFC4_types[630], 2)); }
|
|
std::vector<::Ifc4::IfcPersonAndOrganization> Ifc4::IfcOrganization::Engages() const { return cast_vector<IfcPersonAndOrganization>(file()->getInverse(data()->id(), IFC4_types[648], 1)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcOrganization::Class() { return *((IfcParse::entity*)IFC4_types[629]); }
|
|
void Ifc4::IfcOrganization::initialize(std::optional< std::string > v1_Identification, std::string v2_Name, std::optional< std::string > v3_Description, std::optional< std::vector< ::Ifc4::IfcActorRole > > v4_Roles, std::optional< std::vector< ::Ifc4::IfcAddress > > v5_Addresses) { if (v1_Identification) {set_attribute_value(0, (*v1_Identification)); }set_attribute_value(1, (v2_Name)); if (v3_Description) {set_attribute_value(2, (*v3_Description)); } if (v4_Roles) {set_attribute_value(3, cast_vector<express::Base>(*v4_Roles)); } if (v5_Addresses) {set_attribute_value(4, cast_vector<express::Base>(*v5_Addresses)); } }
|
|
|
|
// Function implementations for IfcOrganizationRelationship
|
|
::Ifc4::IfcOrganization Ifc4::IfcOrganizationRelationship::RelatingOrganization() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcOrganization>(); }
|
|
void Ifc4::IfcOrganizationRelationship::setRelatingOrganization(const ::Ifc4::IfcOrganization& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
std::vector< ::Ifc4::IfcOrganization > Ifc4::IfcOrganizationRelationship::RelatedOrganizations() const { std::vector<express::Base> es = get_attribute_value(3); return cast_vector<::Ifc4::IfcOrganization>(es); }
|
|
void Ifc4::IfcOrganizationRelationship::setRelatedOrganizations(const std::vector< ::Ifc4::IfcOrganization >& v) { set_attribute_value(3, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcOrganizationRelationship::Class() { return *((IfcParse::entity*)IFC4_types[630]); }
|
|
void Ifc4::IfcOrganizationRelationship::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcOrganization v3_RelatingOrganization, std::vector< ::Ifc4::IfcOrganization > v4_RelatedOrganizations) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_RelatingOrganization));set_attribute_value(3, cast_vector<express::Base>(v4_RelatedOrganizations)); }
|
|
|
|
// Function implementations for IfcOrientedEdge
|
|
::Ifc4::IfcEdge Ifc4::IfcOrientedEdge::EdgeElement() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcEdge>(); }
|
|
void Ifc4::IfcOrientedEdge::setEdgeElement(const ::Ifc4::IfcEdge& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
bool Ifc4::IfcOrientedEdge::Orientation() const { bool v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcOrientedEdge::setOrientation(const bool& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcOrientedEdge::Class() { return *((IfcParse::entity*)IFC4_types[631]); }
|
|
void Ifc4::IfcOrientedEdge::initialize(::Ifc4::IfcEdge v3_EdgeElement, bool v4_Orientation) { set_attribute_value(2, (v3_EdgeElement));set_attribute_value(3, (v4_Orientation)); }
|
|
|
|
// Function implementations for IfcOuterBoundaryCurve
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcOuterBoundaryCurve::Class() { return *((IfcParse::entity*)IFC4_types[632]); }
|
|
void Ifc4::IfcOuterBoundaryCurve::initialize(std::vector< ::Ifc4::IfcCompositeCurveSegment > v1_Segments, boost::logic::tribool v2_SelfIntersect) { set_attribute_value(0, cast_vector<express::Base>(v1_Segments));set_attribute_value(1, (v2_SelfIntersect)); }
|
|
|
|
// Function implementations for IfcOutlet
|
|
std::optional< ::Ifc4::IfcOutletTypeEnum::Value > Ifc4::IfcOutlet::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcOutletTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcOutlet::setPredefinedType(const std::optional< ::Ifc4::IfcOutletTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcOutletTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcOutlet::Class() { return *((IfcParse::entity*)IFC4_types[633]); }
|
|
void Ifc4::IfcOutlet::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcOutletTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcOutletTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcOutletType
|
|
::Ifc4::IfcOutletTypeEnum::Value Ifc4::IfcOutletType::PredefinedType() const { return ::Ifc4::IfcOutletTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcOutletType::setPredefinedType(const ::Ifc4::IfcOutletTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcOutletTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcOutletType::Class() { return *((IfcParse::entity*)IFC4_types[634]); }
|
|
void Ifc4::IfcOutletType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcOutletTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcOutletTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcOwnerHistory
|
|
::Ifc4::IfcPersonAndOrganization Ifc4::IfcOwnerHistory::OwningUser() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcPersonAndOrganization>(); }
|
|
void Ifc4::IfcOwnerHistory::setOwningUser(const ::Ifc4::IfcPersonAndOrganization& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcApplication Ifc4::IfcOwnerHistory::OwningApplication() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcApplication>(); }
|
|
void Ifc4::IfcOwnerHistory::setOwningApplication(const ::Ifc4::IfcApplication& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
std::optional< ::Ifc4::IfcStateEnum::Value > Ifc4::IfcOwnerHistory::State() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } return ::Ifc4::IfcStateEnum::FromString(get_attribute_value(2)); }
|
|
void Ifc4::IfcOwnerHistory::setState(const std::optional< ::Ifc4::IfcStateEnum::Value >& v) { if (v) {set_attribute_value(2, EnumerationReference(&::Ifc4::IfcStateEnum::Class(), (size_t) *v));} else {unset_attribute_value(2);} }
|
|
std::optional< ::Ifc4::IfcChangeActionEnum::Value > Ifc4::IfcOwnerHistory::ChangeAction() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } return ::Ifc4::IfcChangeActionEnum::FromString(get_attribute_value(3)); }
|
|
void Ifc4::IfcOwnerHistory::setChangeAction(const std::optional< ::Ifc4::IfcChangeActionEnum::Value >& v) { if (v) {set_attribute_value(3, EnumerationReference(&::Ifc4::IfcChangeActionEnum::Class(), (size_t) *v));} else {unset_attribute_value(3);} }
|
|
std::optional< int > Ifc4::IfcOwnerHistory::LastModifiedDate() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } int v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcOwnerHistory::setLastModifiedDate(const std::optional< int >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
::Ifc4::IfcPersonAndOrganization Ifc4::IfcOwnerHistory::LastModifyingUser() const { if(get_attribute_value(5).isNull()) { return ::Ifc4::IfcPersonAndOrganization{}; } return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcPersonAndOrganization>(); }
|
|
void Ifc4::IfcOwnerHistory::setLastModifyingUser(const ::Ifc4::IfcPersonAndOrganization& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
::Ifc4::IfcApplication Ifc4::IfcOwnerHistory::LastModifyingApplication() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcApplication{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcApplication>(); }
|
|
void Ifc4::IfcOwnerHistory::setLastModifyingApplication(const ::Ifc4::IfcApplication& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
int Ifc4::IfcOwnerHistory::CreationDate() const { int v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcOwnerHistory::setCreationDate(const int& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcOwnerHistory::Class() { return *((IfcParse::entity*)IFC4_types[636]); }
|
|
void Ifc4::IfcOwnerHistory::initialize(::Ifc4::IfcPersonAndOrganization v1_OwningUser, ::Ifc4::IfcApplication v2_OwningApplication, std::optional< ::Ifc4::IfcStateEnum::Value > v3_State, std::optional< ::Ifc4::IfcChangeActionEnum::Value > v4_ChangeAction, std::optional< int > v5_LastModifiedDate, ::Ifc4::IfcPersonAndOrganization v6_LastModifyingUser, ::Ifc4::IfcApplication v7_LastModifyingApplication, int v8_CreationDate) { set_attribute_value(0, (v1_OwningUser));set_attribute_value(1, (v2_OwningApplication)); if (v3_State) {set_attribute_value(2, (EnumerationReference(&::Ifc4::IfcStateEnum::Class(),(size_t)*v3_State))); } if (v4_ChangeAction) {set_attribute_value(3, (EnumerationReference(&::Ifc4::IfcChangeActionEnum::Class(),(size_t)*v4_ChangeAction))); } if (v5_LastModifiedDate) {set_attribute_value(4, (*v5_LastModifiedDate)); }set_attribute_value(5, (v6_LastModifyingUser));set_attribute_value(6, (v7_LastModifyingApplication));set_attribute_value(7, (v8_CreationDate)); }
|
|
|
|
// Function implementations for IfcParameterizedProfileDef
|
|
::Ifc4::IfcAxis2Placement2D Ifc4::IfcParameterizedProfileDef::Position() const { if(get_attribute_value(2).isNull()) { return ::Ifc4::IfcAxis2Placement2D{}; } return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcAxis2Placement2D>(); }
|
|
void Ifc4::IfcParameterizedProfileDef::setPosition(const ::Ifc4::IfcAxis2Placement2D& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcParameterizedProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[637]); }
|
|
void Ifc4::IfcParameterizedProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcAxis2Placement2D v3_Position) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Position)); }
|
|
|
|
// Function implementations for IfcPath
|
|
std::vector< ::Ifc4::IfcOrientedEdge > Ifc4::IfcPath::EdgeList() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcOrientedEdge>(es); }
|
|
void Ifc4::IfcPath::setEdgeList(const std::vector< ::Ifc4::IfcOrientedEdge >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPath::Class() { return *((IfcParse::entity*)IFC4_types[639]); }
|
|
void Ifc4::IfcPath::initialize(std::vector< ::Ifc4::IfcOrientedEdge > v1_EdgeList) { set_attribute_value(0, cast_vector<express::Base>(v1_EdgeList)); }
|
|
|
|
// Function implementations for IfcPcurve
|
|
::Ifc4::IfcSurface Ifc4::IfcPcurve::BasisSurface() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcSurface>(); }
|
|
void Ifc4::IfcPcurve::setBasisSurface(const ::Ifc4::IfcSurface& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcCurve Ifc4::IfcPcurve::ReferenceCurve() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcCurve>(); }
|
|
void Ifc4::IfcPcurve::setReferenceCurve(const ::Ifc4::IfcCurve& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPcurve::Class() { return *((IfcParse::entity*)IFC4_types[640]); }
|
|
void Ifc4::IfcPcurve::initialize(::Ifc4::IfcSurface v1_BasisSurface, ::Ifc4::IfcCurve v2_ReferenceCurve) { set_attribute_value(0, (v1_BasisSurface));set_attribute_value(1, (v2_ReferenceCurve)); }
|
|
|
|
// Function implementations for IfcPerformanceHistory
|
|
std::string Ifc4::IfcPerformanceHistory::LifeCyclePhase() const { std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcPerformanceHistory::setLifeCyclePhase(const std::string& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
std::optional< ::Ifc4::IfcPerformanceHistoryTypeEnum::Value > Ifc4::IfcPerformanceHistory::PredefinedType() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } return ::Ifc4::IfcPerformanceHistoryTypeEnum::FromString(get_attribute_value(7)); }
|
|
void Ifc4::IfcPerformanceHistory::setPredefinedType(const std::optional< ::Ifc4::IfcPerformanceHistoryTypeEnum::Value >& v) { if (v) {set_attribute_value(7, EnumerationReference(&::Ifc4::IfcPerformanceHistoryTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(7);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPerformanceHistory::Class() { return *((IfcParse::entity*)IFC4_types[641]); }
|
|
void Ifc4::IfcPerformanceHistory::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::string v7_LifeCyclePhase, std::optional< ::Ifc4::IfcPerformanceHistoryTypeEnum::Value > v8_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); }set_attribute_value(6, (v7_LifeCyclePhase)); if (v8_PredefinedType) {set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcPerformanceHistoryTypeEnum::Class(),(size_t)*v8_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcPermeableCoveringProperties
|
|
::Ifc4::IfcPermeableCoveringOperationEnum::Value Ifc4::IfcPermeableCoveringProperties::OperationType() const { return ::Ifc4::IfcPermeableCoveringOperationEnum::FromString(get_attribute_value(4)); }
|
|
void Ifc4::IfcPermeableCoveringProperties::setOperationType(const ::Ifc4::IfcPermeableCoveringOperationEnum::Value& v) { set_attribute_value(4, EnumerationReference(&::Ifc4::IfcPermeableCoveringOperationEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcWindowPanelPositionEnum::Value Ifc4::IfcPermeableCoveringProperties::PanelPosition() const { return ::Ifc4::IfcWindowPanelPositionEnum::FromString(get_attribute_value(5)); }
|
|
void Ifc4::IfcPermeableCoveringProperties::setPanelPosition(const ::Ifc4::IfcWindowPanelPositionEnum::Value& v) { set_attribute_value(5, EnumerationReference(&::Ifc4::IfcWindowPanelPositionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(5); }
|
|
std::optional< double > Ifc4::IfcPermeableCoveringProperties::FrameDepth() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcPermeableCoveringProperties::setFrameDepth(const std::optional< double >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
std::optional< double > Ifc4::IfcPermeableCoveringProperties::FrameThickness() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcPermeableCoveringProperties::setFrameThickness(const std::optional< double >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
::Ifc4::IfcShapeAspect Ifc4::IfcPermeableCoveringProperties::ShapeAspectStyle() const { if(get_attribute_value(8).isNull()) { return ::Ifc4::IfcShapeAspect{}; } return ((express::Base)(get_attribute_value(8))).as<::Ifc4::IfcShapeAspect>(); }
|
|
void Ifc4::IfcPermeableCoveringProperties::setShapeAspectStyle(const ::Ifc4::IfcShapeAspect& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPermeableCoveringProperties::Class() { return *((IfcParse::entity*)IFC4_types[644]); }
|
|
void Ifc4::IfcPermeableCoveringProperties::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcPermeableCoveringOperationEnum::Value v5_OperationType, ::Ifc4::IfcWindowPanelPositionEnum::Value v6_PanelPosition, std::optional< double > v7_FrameDepth, std::optional< double > v8_FrameThickness, ::Ifc4::IfcShapeAspect v9_ShapeAspectStyle) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (EnumerationReference(&::Ifc4::IfcPermeableCoveringOperationEnum::Class(),(size_t)v5_OperationType)));set_attribute_value(5, (EnumerationReference(&::Ifc4::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)); }
|
|
|
|
// Function implementations for IfcPermit
|
|
std::optional< ::Ifc4::IfcPermitTypeEnum::Value > Ifc4::IfcPermit::PredefinedType() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } return ::Ifc4::IfcPermitTypeEnum::FromString(get_attribute_value(6)); }
|
|
void Ifc4::IfcPermit::setPredefinedType(const std::optional< ::Ifc4::IfcPermitTypeEnum::Value >& v) { if (v) {set_attribute_value(6, EnumerationReference(&::Ifc4::IfcPermitTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(6);} }
|
|
std::optional< std::string > Ifc4::IfcPermit::Status() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::string v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcPermit::setStatus(const std::optional< std::string >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< std::string > Ifc4::IfcPermit::LongDescription() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcPermit::setLongDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPermit::Class() { return *((IfcParse::entity*)IFC4_types[645]); }
|
|
void Ifc4::IfcPermit::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< ::Ifc4::IfcPermitTypeEnum::Value > v7_PredefinedType, std::optional< std::string > v8_Status, std::optional< std::string > v9_LongDescription) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_PredefinedType) {set_attribute_value(6, (EnumerationReference(&::Ifc4::IfcPermitTypeEnum::Class(),(size_t)*v7_PredefinedType))); } if (v8_Status) {set_attribute_value(7, (*v8_Status)); } if (v9_LongDescription) {set_attribute_value(8, (*v9_LongDescription)); } }
|
|
|
|
// Function implementations for IfcPerson
|
|
std::optional< std::string > Ifc4::IfcPerson::Identification() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcPerson::setIdentification(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< std::string > Ifc4::IfcPerson::FamilyName() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcPerson::setFamilyName(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< std::string > Ifc4::IfcPerson::GivenName() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcPerson::setGivenName(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< std::vector< std::string > /*[1:?]*/ > Ifc4::IfcPerson::MiddleNames() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcPerson::setMiddleNames(const std::optional< std::vector< std::string > /*[1:?]*/ >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< std::vector< std::string > /*[1:?]*/ > Ifc4::IfcPerson::PrefixTitles() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcPerson::setPrefixTitles(const std::optional< std::vector< std::string > /*[1:?]*/ >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::vector< std::string > /*[1:?]*/ > Ifc4::IfcPerson::SuffixTitles() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcPerson::setSuffixTitles(const std::optional< std::vector< std::string > /*[1:?]*/ >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< std::vector< ::Ifc4::IfcActorRole > > Ifc4::IfcPerson::Roles() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(6); return cast_vector<::Ifc4::IfcActorRole>(es); }
|
|
void Ifc4::IfcPerson::setRoles(const std::optional< std::vector< ::Ifc4::IfcActorRole > >& v) { if (v) {set_attribute_value(6, cast_vector<express::Base>(*v));} else {unset_attribute_value(6);} }
|
|
std::optional< std::vector< ::Ifc4::IfcAddress > > Ifc4::IfcPerson::Addresses() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(7); return cast_vector<::Ifc4::IfcAddress>(es); }
|
|
void Ifc4::IfcPerson::setAddresses(const std::optional< std::vector< ::Ifc4::IfcAddress > >& v) { if (v) {set_attribute_value(7, cast_vector<express::Base>(*v));} else {unset_attribute_value(7);} }
|
|
|
|
std::vector<::Ifc4::IfcPersonAndOrganization> Ifc4::IfcPerson::EngagedIn() const { return cast_vector<IfcPersonAndOrganization>(file()->getInverse(data()->id(), IFC4_types[648], 0)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcPerson::Class() { return *((IfcParse::entity*)IFC4_types[647]); }
|
|
void Ifc4::IfcPerson::initialize(std::optional< std::string > v1_Identification, std::optional< std::string > v2_FamilyName, std::optional< std::string > v3_GivenName, std::optional< std::vector< std::string > /*[1:?]*/ > v4_MiddleNames, std::optional< std::vector< std::string > /*[1:?]*/ > v5_PrefixTitles, std::optional< std::vector< std::string > /*[1:?]*/ > v6_SuffixTitles, std::optional< std::vector< ::Ifc4::IfcActorRole > > v7_Roles, std::optional< std::vector< ::Ifc4::IfcAddress > > v8_Addresses) { if (v1_Identification) {set_attribute_value(0, (*v1_Identification)); } 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, cast_vector<express::Base>(*v7_Roles)); } if (v8_Addresses) {set_attribute_value(7, cast_vector<express::Base>(*v8_Addresses)); } }
|
|
|
|
// Function implementations for IfcPersonAndOrganization
|
|
::Ifc4::IfcPerson Ifc4::IfcPersonAndOrganization::ThePerson() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcPerson>(); }
|
|
void Ifc4::IfcPersonAndOrganization::setThePerson(const ::Ifc4::IfcPerson& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcOrganization Ifc4::IfcPersonAndOrganization::TheOrganization() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcOrganization>(); }
|
|
void Ifc4::IfcPersonAndOrganization::setTheOrganization(const ::Ifc4::IfcOrganization& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
std::optional< std::vector< ::Ifc4::IfcActorRole > > Ifc4::IfcPersonAndOrganization::Roles() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcActorRole>(es); }
|
|
void Ifc4::IfcPersonAndOrganization::setRoles(const std::optional< std::vector< ::Ifc4::IfcActorRole > >& v) { if (v) {set_attribute_value(2, cast_vector<express::Base>(*v));} else {unset_attribute_value(2);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPersonAndOrganization::Class() { return *((IfcParse::entity*)IFC4_types[648]); }
|
|
void Ifc4::IfcPersonAndOrganization::initialize(::Ifc4::IfcPerson v1_ThePerson, ::Ifc4::IfcOrganization v2_TheOrganization, std::optional< std::vector< ::Ifc4::IfcActorRole > > v3_Roles) { set_attribute_value(0, (v1_ThePerson));set_attribute_value(1, (v2_TheOrganization)); if (v3_Roles) {set_attribute_value(2, cast_vector<express::Base>(*v3_Roles)); } }
|
|
|
|
// Function implementations for IfcPhysicalComplexQuantity
|
|
std::vector< ::Ifc4::IfcPhysicalQuantity > Ifc4::IfcPhysicalComplexQuantity::HasQuantities() const { std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcPhysicalQuantity>(es); }
|
|
void Ifc4::IfcPhysicalComplexQuantity::setHasQuantities(const std::vector< ::Ifc4::IfcPhysicalQuantity >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
|
|
std::string Ifc4::IfcPhysicalComplexQuantity::Discrimination() const { std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcPhysicalComplexQuantity::setDiscrimination(const std::string& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< std::string > Ifc4::IfcPhysicalComplexQuantity::Quality() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcPhysicalComplexQuantity::setQuality(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcPhysicalComplexQuantity::Usage() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcPhysicalComplexQuantity::setUsage(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPhysicalComplexQuantity::Class() { return *((IfcParse::entity*)IFC4_types[650]); }
|
|
void Ifc4::IfcPhysicalComplexQuantity::initialize(std::string v1_Name, std::optional< std::string > v2_Description, std::vector< ::Ifc4::IfcPhysicalQuantity > v3_HasQuantities, std::string v4_Discrimination, std::optional< std::string > v5_Quality, std::optional< std::string > v6_Usage) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, cast_vector<express::Base>(v3_HasQuantities));set_attribute_value(3, (v4_Discrimination)); if (v5_Quality) {set_attribute_value(4, (*v5_Quality)); } if (v6_Usage) {set_attribute_value(5, (*v6_Usage)); } }
|
|
|
|
// Function implementations for IfcPhysicalQuantity
|
|
std::string Ifc4::IfcPhysicalQuantity::Name() const { std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcPhysicalQuantity::setName(const std::string& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< std::string > Ifc4::IfcPhysicalQuantity::Description() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcPhysicalQuantity::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
|
|
std::vector<::Ifc4::IfcExternalReferenceRelationship> Ifc4::IfcPhysicalQuantity::HasExternalReferences() const { return cast_vector<IfcExternalReferenceRelationship>(file()->getInverse(data()->id(), IFC4_types[380], 3)); }
|
|
std::vector<::Ifc4::IfcPhysicalComplexQuantity> Ifc4::IfcPhysicalQuantity::PartOfComplex() const { return cast_vector<IfcPhysicalComplexQuantity>(file()->getInverse(data()->id(), IFC4_types[650], 2)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcPhysicalQuantity::Class() { return *((IfcParse::entity*)IFC4_types[652]); }
|
|
void Ifc4::IfcPhysicalQuantity::initialize(std::string v1_Name, std::optional< std::string > v2_Description) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); } }
|
|
|
|
// Function implementations for IfcPhysicalSimpleQuantity
|
|
::Ifc4::IfcNamedUnit Ifc4::IfcPhysicalSimpleQuantity::Unit() const { if(get_attribute_value(2).isNull()) { return ::Ifc4::IfcNamedUnit{}; } return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcNamedUnit>(); }
|
|
void Ifc4::IfcPhysicalSimpleQuantity::setUnit(const ::Ifc4::IfcNamedUnit& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPhysicalSimpleQuantity::Class() { return *((IfcParse::entity*)IFC4_types[653]); }
|
|
void Ifc4::IfcPhysicalSimpleQuantity::initialize(std::string v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcNamedUnit v3_Unit) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_Unit)); }
|
|
|
|
// Function implementations for IfcPile
|
|
std::optional< ::Ifc4::IfcPileTypeEnum::Value > Ifc4::IfcPile::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcPileTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcPile::setPredefinedType(const std::optional< ::Ifc4::IfcPileTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcPileTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
std::optional< ::Ifc4::IfcPileConstructionEnum::Value > Ifc4::IfcPile::ConstructionType() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } return ::Ifc4::IfcPileConstructionEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcPile::setConstructionType(const std::optional< ::Ifc4::IfcPileConstructionEnum::Value >& v) { if (v) {set_attribute_value(9, EnumerationReference(&::Ifc4::IfcPileConstructionEnum::Class(), (size_t) *v));} else {unset_attribute_value(9);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPile::Class() { return *((IfcParse::entity*)IFC4_types[654]); }
|
|
void Ifc4::IfcPile::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcPileTypeEnum::Value > v9_PredefinedType, std::optional< ::Ifc4::IfcPileConstructionEnum::Value > v10_ConstructionType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcPileTypeEnum::Class(),(size_t)*v9_PredefinedType))); } if (v10_ConstructionType) {set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcPileConstructionEnum::Class(),(size_t)*v10_ConstructionType))); } }
|
|
|
|
// Function implementations for IfcPileType
|
|
::Ifc4::IfcPileTypeEnum::Value Ifc4::IfcPileType::PredefinedType() const { return ::Ifc4::IfcPileTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcPileType::setPredefinedType(const ::Ifc4::IfcPileTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcPileTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPileType::Class() { return *((IfcParse::entity*)IFC4_types[656]); }
|
|
void Ifc4::IfcPileType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcPileTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcPileTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcPipeFitting
|
|
std::optional< ::Ifc4::IfcPipeFittingTypeEnum::Value > Ifc4::IfcPipeFitting::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcPipeFittingTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcPipeFitting::setPredefinedType(const std::optional< ::Ifc4::IfcPipeFittingTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcPipeFittingTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPipeFitting::Class() { return *((IfcParse::entity*)IFC4_types[658]); }
|
|
void Ifc4::IfcPipeFitting::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcPipeFittingTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcPipeFittingTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcPipeFittingType
|
|
::Ifc4::IfcPipeFittingTypeEnum::Value Ifc4::IfcPipeFittingType::PredefinedType() const { return ::Ifc4::IfcPipeFittingTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcPipeFittingType::setPredefinedType(const ::Ifc4::IfcPipeFittingTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcPipeFittingTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPipeFittingType::Class() { return *((IfcParse::entity*)IFC4_types[659]); }
|
|
void Ifc4::IfcPipeFittingType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcPipeFittingTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcPipeFittingTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcPipeSegment
|
|
std::optional< ::Ifc4::IfcPipeSegmentTypeEnum::Value > Ifc4::IfcPipeSegment::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcPipeSegmentTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcPipeSegment::setPredefinedType(const std::optional< ::Ifc4::IfcPipeSegmentTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcPipeSegmentTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPipeSegment::Class() { return *((IfcParse::entity*)IFC4_types[661]); }
|
|
void Ifc4::IfcPipeSegment::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcPipeSegmentTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcPipeSegmentTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcPipeSegmentType
|
|
::Ifc4::IfcPipeSegmentTypeEnum::Value Ifc4::IfcPipeSegmentType::PredefinedType() const { return ::Ifc4::IfcPipeSegmentTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcPipeSegmentType::setPredefinedType(const ::Ifc4::IfcPipeSegmentTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcPipeSegmentTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPipeSegmentType::Class() { return *((IfcParse::entity*)IFC4_types[662]); }
|
|
void Ifc4::IfcPipeSegmentType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcPipeSegmentTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcPipeSegmentTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcPixelTexture
|
|
int Ifc4::IfcPixelTexture::Width() const { int v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcPixelTexture::setWidth(const int& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
int Ifc4::IfcPixelTexture::Height() const { int v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcPixelTexture::setHeight(const int& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
int Ifc4::IfcPixelTexture::ColourComponents() const { int v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcPixelTexture::setColourComponents(const int& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
std::vector< boost::dynamic_bitset<> > /*[1:?]*/ Ifc4::IfcPixelTexture::Pixel() const { std::vector< boost::dynamic_bitset<> > /*[1:?]*/ v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcPixelTexture::setPixel(const std::vector< boost::dynamic_bitset<> > /*[1:?]*/& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPixelTexture::Class() { return *((IfcParse::entity*)IFC4_types[664]); }
|
|
void Ifc4::IfcPixelTexture::initialize(bool v1_RepeatS, bool v2_RepeatT, std::optional< std::string > v3_Mode, ::Ifc4::IfcCartesianTransformationOperator2D v4_TextureTransform, std::optional< std::vector< std::string > /*[1:?]*/ > v5_Parameter, int v6_Width, int v7_Height, int v8_ColourComponents, std::vector< boost::dynamic_bitset<> > /*[1:?]*/ v9_Pixel) { set_attribute_value(0, (v1_RepeatS));set_attribute_value(1, (v2_RepeatT)); if (v3_Mode) {set_attribute_value(2, (*v3_Mode)); }set_attribute_value(3, (v4_TextureTransform)); if (v5_Parameter) {set_attribute_value(4, (*v5_Parameter)); }set_attribute_value(5, (v6_Width));set_attribute_value(6, (v7_Height));set_attribute_value(7, (v8_ColourComponents));set_attribute_value(8, (v9_Pixel)); }
|
|
|
|
// Function implementations for IfcPlacement
|
|
::Ifc4::IfcCartesianPoint Ifc4::IfcPlacement::Location() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcCartesianPoint>(); }
|
|
void Ifc4::IfcPlacement::setLocation(const ::Ifc4::IfcCartesianPoint& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPlacement::Class() { return *((IfcParse::entity*)IFC4_types[665]); }
|
|
void Ifc4::IfcPlacement::initialize(::Ifc4::IfcCartesianPoint v1_Location) { set_attribute_value(0, (v1_Location)); }
|
|
|
|
// Function implementations for IfcPlanarBox
|
|
::Ifc4::IfcAxis2Placement Ifc4::IfcPlanarBox::Placement() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcAxis2Placement>(); }
|
|
void Ifc4::IfcPlanarBox::setPlacement(const ::Ifc4::IfcAxis2Placement& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPlanarBox::Class() { return *((IfcParse::entity*)IFC4_types[666]); }
|
|
void Ifc4::IfcPlanarBox::initialize(double v1_SizeInX, double v2_SizeInY, ::Ifc4::IfcAxis2Placement v3_Placement) { set_attribute_value(0, (v1_SizeInX));set_attribute_value(1, (v2_SizeInY));set_attribute_value(2, (v3_Placement)); }
|
|
|
|
// Function implementations for IfcPlanarExtent
|
|
double Ifc4::IfcPlanarExtent::SizeInX() const { double v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcPlanarExtent::setSizeInX(const double& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
double Ifc4::IfcPlanarExtent::SizeInY() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcPlanarExtent::setSizeInY(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPlanarExtent::Class() { return *((IfcParse::entity*)IFC4_types[667]); }
|
|
void Ifc4::IfcPlanarExtent::initialize(double v1_SizeInX, double v2_SizeInY) { set_attribute_value(0, (v1_SizeInX));set_attribute_value(1, (v2_SizeInY)); }
|
|
|
|
// Function implementations for IfcPlane
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPlane::Class() { return *((IfcParse::entity*)IFC4_types[669]); }
|
|
void Ifc4::IfcPlane::initialize(::Ifc4::IfcAxis2Placement3D v1_Position) { set_attribute_value(0, (v1_Position)); }
|
|
|
|
// Function implementations for IfcPlate
|
|
std::optional< ::Ifc4::IfcPlateTypeEnum::Value > Ifc4::IfcPlate::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcPlateTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcPlate::setPredefinedType(const std::optional< ::Ifc4::IfcPlateTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcPlateTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPlate::Class() { return *((IfcParse::entity*)IFC4_types[671]); }
|
|
void Ifc4::IfcPlate::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcPlateTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcPlateTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcPlateStandardCase
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPlateStandardCase::Class() { return *((IfcParse::entity*)IFC4_types[672]); }
|
|
void Ifc4::IfcPlateStandardCase::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcPlateTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcPlateTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcPlateType
|
|
::Ifc4::IfcPlateTypeEnum::Value Ifc4::IfcPlateType::PredefinedType() const { return ::Ifc4::IfcPlateTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcPlateType::setPredefinedType(const ::Ifc4::IfcPlateTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcPlateTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPlateType::Class() { return *((IfcParse::entity*)IFC4_types[673]); }
|
|
void Ifc4::IfcPlateType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcPlateTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcPlateTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcPoint
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPoint::Class() { return *((IfcParse::entity*)IFC4_types[675]); }
|
|
void Ifc4::IfcPoint::initialize() { }
|
|
|
|
// Function implementations for IfcPointOnCurve
|
|
::Ifc4::IfcCurve Ifc4::IfcPointOnCurve::BasisCurve() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcCurve>(); }
|
|
void Ifc4::IfcPointOnCurve::setBasisCurve(const ::Ifc4::IfcCurve& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
double Ifc4::IfcPointOnCurve::PointParameter() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcPointOnCurve::setPointParameter(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPointOnCurve::Class() { return *((IfcParse::entity*)IFC4_types[676]); }
|
|
void Ifc4::IfcPointOnCurve::initialize(::Ifc4::IfcCurve v1_BasisCurve, double v2_PointParameter) { set_attribute_value(0, (v1_BasisCurve));set_attribute_value(1, (v2_PointParameter)); }
|
|
|
|
// Function implementations for IfcPointOnSurface
|
|
::Ifc4::IfcSurface Ifc4::IfcPointOnSurface::BasisSurface() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcSurface>(); }
|
|
void Ifc4::IfcPointOnSurface::setBasisSurface(const ::Ifc4::IfcSurface& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
double Ifc4::IfcPointOnSurface::PointParameterU() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcPointOnSurface::setPointParameterU(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
double Ifc4::IfcPointOnSurface::PointParameterV() const { double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcPointOnSurface::setPointParameterV(const double& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPointOnSurface::Class() { return *((IfcParse::entity*)IFC4_types[677]); }
|
|
void Ifc4::IfcPointOnSurface::initialize(::Ifc4::IfcSurface v1_BasisSurface, double v2_PointParameterU, double v3_PointParameterV) { set_attribute_value(0, (v1_BasisSurface));set_attribute_value(1, (v2_PointParameterU));set_attribute_value(2, (v3_PointParameterV)); }
|
|
|
|
// Function implementations for IfcPolyLoop
|
|
std::vector< ::Ifc4::IfcCartesianPoint > Ifc4::IfcPolyLoop::Polygon() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcCartesianPoint>(es); }
|
|
void Ifc4::IfcPolyLoop::setPolygon(const std::vector< ::Ifc4::IfcCartesianPoint >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPolyLoop::Class() { return *((IfcParse::entity*)IFC4_types[682]); }
|
|
void Ifc4::IfcPolyLoop::initialize(std::vector< ::Ifc4::IfcCartesianPoint > v1_Polygon) { set_attribute_value(0, cast_vector<express::Base>(v1_Polygon)); }
|
|
|
|
// Function implementations for IfcPolygonalBoundedHalfSpace
|
|
::Ifc4::IfcAxis2Placement3D Ifc4::IfcPolygonalBoundedHalfSpace::Position() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcAxis2Placement3D>(); }
|
|
void Ifc4::IfcPolygonalBoundedHalfSpace::setPosition(const ::Ifc4::IfcAxis2Placement3D& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcBoundedCurve Ifc4::IfcPolygonalBoundedHalfSpace::PolygonalBoundary() const { return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcBoundedCurve>(); }
|
|
void Ifc4::IfcPolygonalBoundedHalfSpace::setPolygonalBoundary(const ::Ifc4::IfcBoundedCurve& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPolygonalBoundedHalfSpace::Class() { return *((IfcParse::entity*)IFC4_types[679]); }
|
|
void Ifc4::IfcPolygonalBoundedHalfSpace::initialize(::Ifc4::IfcSurface v1_BaseSurface, bool v2_AgreementFlag, ::Ifc4::IfcAxis2Placement3D v3_Position, ::Ifc4::IfcBoundedCurve v4_PolygonalBoundary) { set_attribute_value(0, (v1_BaseSurface));set_attribute_value(1, (v2_AgreementFlag));set_attribute_value(2, (v3_Position));set_attribute_value(3, (v4_PolygonalBoundary)); }
|
|
|
|
// Function implementations for IfcPolygonalFaceSet
|
|
std::optional< bool > Ifc4::IfcPolygonalFaceSet::Closed() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } bool v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcPolygonalFaceSet::setClosed(const std::optional< bool >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::vector< ::Ifc4::IfcIndexedPolygonalFace > Ifc4::IfcPolygonalFaceSet::Faces() const { std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcIndexedPolygonalFace>(es); }
|
|
void Ifc4::IfcPolygonalFaceSet::setFaces(const std::vector< ::Ifc4::IfcIndexedPolygonalFace >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
|
|
std::optional< std::vector< int > /*[1:?]*/ > Ifc4::IfcPolygonalFaceSet::PnIndex() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::vector< int > /*[1:?]*/ v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcPolygonalFaceSet::setPnIndex(const std::optional< std::vector< int > /*[1:?]*/ >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPolygonalFaceSet::Class() { return *((IfcParse::entity*)IFC4_types[680]); }
|
|
void Ifc4::IfcPolygonalFaceSet::initialize(::Ifc4::IfcCartesianPointList3D v1_Coordinates, std::optional< bool > v2_Closed, std::vector< ::Ifc4::IfcIndexedPolygonalFace > v3_Faces, std::optional< std::vector< int > /*[1:?]*/ > v4_PnIndex) { set_attribute_value(0, (v1_Coordinates)); if (v2_Closed) {set_attribute_value(1, (*v2_Closed)); }set_attribute_value(2, cast_vector<express::Base>(v3_Faces)); if (v4_PnIndex) {set_attribute_value(3, (*v4_PnIndex)); } }
|
|
|
|
// Function implementations for IfcPolyline
|
|
std::vector< ::Ifc4::IfcCartesianPoint > Ifc4::IfcPolyline::Points() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcCartesianPoint>(es); }
|
|
void Ifc4::IfcPolyline::setPoints(const std::vector< ::Ifc4::IfcCartesianPoint >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPolyline::Class() { return *((IfcParse::entity*)IFC4_types[681]); }
|
|
void Ifc4::IfcPolyline::initialize(std::vector< ::Ifc4::IfcCartesianPoint > v1_Points) { set_attribute_value(0, cast_vector<express::Base>(v1_Points)); }
|
|
|
|
// Function implementations for IfcPort
|
|
|
|
std::vector<::Ifc4::IfcRelConnectsPortToElement> Ifc4::IfcPort::ContainedIn() const { return cast_vector<IfcRelConnectsPortToElement>(file()->getInverse(data()->id(), IFC4_types[818], 4)); }
|
|
std::vector<::Ifc4::IfcRelConnectsPorts> Ifc4::IfcPort::ConnectedFrom() const { return cast_vector<IfcRelConnectsPorts>(file()->getInverse(data()->id(), IFC4_types[817], 5)); }
|
|
std::vector<::Ifc4::IfcRelConnectsPorts> Ifc4::IfcPort::ConnectedTo() const { return cast_vector<IfcRelConnectsPorts>(file()->getInverse(data()->id(), IFC4_types[817], 4)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcPort::Class() { return *((IfcParse::entity*)IFC4_types[683]); }
|
|
void Ifc4::IfcPort::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); }
|
|
|
|
// Function implementations for IfcPostalAddress
|
|
std::optional< std::string > Ifc4::IfcPostalAddress::InternalLocation() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcPostalAddress::setInternalLocation(const std::optional< std::string >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< std::vector< std::string > /*[1:?]*/ > Ifc4::IfcPostalAddress::AddressLines() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcPostalAddress::setAddressLines(const std::optional< std::vector< std::string > /*[1:?]*/ >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcPostalAddress::PostalBox() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcPostalAddress::setPostalBox(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< std::string > Ifc4::IfcPostalAddress::Town() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcPostalAddress::setTown(const std::optional< std::string >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
std::optional< std::string > Ifc4::IfcPostalAddress::Region() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::string v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcPostalAddress::setRegion(const std::optional< std::string >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< std::string > Ifc4::IfcPostalAddress::PostalCode() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcPostalAddress::setPostalCode(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
std::optional< std::string > Ifc4::IfcPostalAddress::Country() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } std::string v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcPostalAddress::setCountry(const std::optional< std::string >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPostalAddress::Class() { return *((IfcParse::entity*)IFC4_types[688]); }
|
|
void Ifc4::IfcPostalAddress::initialize(std::optional< ::Ifc4::IfcAddressTypeEnum::Value > v1_Purpose, std::optional< std::string > v2_Description, std::optional< std::string > v3_UserDefinedPurpose, std::optional< std::string > v4_InternalLocation, std::optional< std::vector< std::string > /*[1:?]*/ > v5_AddressLines, std::optional< std::string > v6_PostalBox, std::optional< std::string > v7_Town, std::optional< std::string > v8_Region, std::optional< std::string > v9_PostalCode, std::optional< std::string > v10_Country) { if (v1_Purpose) {set_attribute_value(0, (EnumerationReference(&::Ifc4::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)); } }
|
|
|
|
// Function implementations for IfcPreDefinedColour
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPreDefinedColour::Class() { return *((IfcParse::entity*)IFC4_types[690]); }
|
|
void Ifc4::IfcPreDefinedColour::initialize(std::string v1_Name) { set_attribute_value(0, (v1_Name)); }
|
|
|
|
// Function implementations for IfcPreDefinedCurveFont
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPreDefinedCurveFont::Class() { return *((IfcParse::entity*)IFC4_types[691]); }
|
|
void Ifc4::IfcPreDefinedCurveFont::initialize(std::string v1_Name) { set_attribute_value(0, (v1_Name)); }
|
|
|
|
// Function implementations for IfcPreDefinedItem
|
|
std::string Ifc4::IfcPreDefinedItem::Name() const { std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcPreDefinedItem::setName(const std::string& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPreDefinedItem::Class() { return *((IfcParse::entity*)IFC4_types[692]); }
|
|
void Ifc4::IfcPreDefinedItem::initialize(std::string v1_Name) { set_attribute_value(0, (v1_Name)); }
|
|
|
|
// Function implementations for IfcPreDefinedProperties
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPreDefinedProperties::Class() { return *((IfcParse::entity*)IFC4_types[693]); }
|
|
void Ifc4::IfcPreDefinedProperties::initialize() { }
|
|
|
|
// Function implementations for IfcPreDefinedPropertySet
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPreDefinedPropertySet::Class() { return *((IfcParse::entity*)IFC4_types[694]); }
|
|
void Ifc4::IfcPreDefinedPropertySet::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } }
|
|
|
|
// Function implementations for IfcPreDefinedTextFont
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPreDefinedTextFont::Class() { return *((IfcParse::entity*)IFC4_types[695]); }
|
|
void Ifc4::IfcPreDefinedTextFont::initialize(std::string v1_Name) { set_attribute_value(0, (v1_Name)); }
|
|
|
|
// Function implementations for IfcPresentationItem
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPresentationItem::Class() { return *((IfcParse::entity*)IFC4_types[698]); }
|
|
void Ifc4::IfcPresentationItem::initialize() { }
|
|
|
|
// Function implementations for IfcPresentationLayerAssignment
|
|
std::string Ifc4::IfcPresentationLayerAssignment::Name() const { std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcPresentationLayerAssignment::setName(const std::string& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< std::string > Ifc4::IfcPresentationLayerAssignment::Description() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcPresentationLayerAssignment::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::vector< ::Ifc4::IfcLayeredItem > Ifc4::IfcPresentationLayerAssignment::AssignedItems() const { std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcLayeredItem>(es); }
|
|
void Ifc4::IfcPresentationLayerAssignment::setAssignedItems(const std::vector< ::Ifc4::IfcLayeredItem >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
|
|
std::optional< std::string > Ifc4::IfcPresentationLayerAssignment::Identifier() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcPresentationLayerAssignment::setIdentifier(const std::optional< std::string >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPresentationLayerAssignment::Class() { return *((IfcParse::entity*)IFC4_types[699]); }
|
|
void Ifc4::IfcPresentationLayerAssignment::initialize(std::string v1_Name, std::optional< std::string > v2_Description, std::vector< ::Ifc4::IfcLayeredItem > v3_AssignedItems, std::optional< std::string > v4_Identifier) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, cast_vector<express::Base>(v3_AssignedItems)); if (v4_Identifier) {set_attribute_value(3, (*v4_Identifier)); } }
|
|
|
|
// Function implementations for IfcPresentationLayerWithStyle
|
|
boost::logic::tribool Ifc4::IfcPresentationLayerWithStyle::LayerOn() const { boost::logic::tribool v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcPresentationLayerWithStyle::setLayerOn(const boost::logic::tribool& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
boost::logic::tribool Ifc4::IfcPresentationLayerWithStyle::LayerFrozen() const { boost::logic::tribool v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcPresentationLayerWithStyle::setLayerFrozen(const boost::logic::tribool& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
boost::logic::tribool Ifc4::IfcPresentationLayerWithStyle::LayerBlocked() const { boost::logic::tribool v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcPresentationLayerWithStyle::setLayerBlocked(const boost::logic::tribool& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
std::vector< ::Ifc4::IfcPresentationStyle > Ifc4::IfcPresentationLayerWithStyle::LayerStyles() const { std::vector<express::Base> es = get_attribute_value(7); return cast_vector<::Ifc4::IfcPresentationStyle>(es); }
|
|
void Ifc4::IfcPresentationLayerWithStyle::setLayerStyles(const std::vector< ::Ifc4::IfcPresentationStyle >& v) { set_attribute_value(7, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(7); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPresentationLayerWithStyle::Class() { return *((IfcParse::entity*)IFC4_types[700]); }
|
|
void Ifc4::IfcPresentationLayerWithStyle::initialize(std::string v1_Name, std::optional< std::string > v2_Description, std::vector< ::Ifc4::IfcLayeredItem > v3_AssignedItems, std::optional< std::string > v4_Identifier, boost::logic::tribool v5_LayerOn, boost::logic::tribool v6_LayerFrozen, boost::logic::tribool v7_LayerBlocked, std::vector< ::Ifc4::IfcPresentationStyle > v8_LayerStyles) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, cast_vector<express::Base>(v3_AssignedItems)); 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, cast_vector<express::Base>(v8_LayerStyles)); }
|
|
|
|
// Function implementations for IfcPresentationStyle
|
|
std::optional< std::string > Ifc4::IfcPresentationStyle::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcPresentationStyle::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPresentationStyle::Class() { return *((IfcParse::entity*)IFC4_types[701]); }
|
|
void Ifc4::IfcPresentationStyle::initialize(std::optional< std::string > v1_Name) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } }
|
|
|
|
// Function implementations for IfcPresentationStyleAssignment
|
|
std::vector< ::Ifc4::IfcPresentationStyleSelect > Ifc4::IfcPresentationStyleAssignment::Styles() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcPresentationStyleSelect>(es); }
|
|
void Ifc4::IfcPresentationStyleAssignment::setStyles(const std::vector< ::Ifc4::IfcPresentationStyleSelect >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPresentationStyleAssignment::Class() { return *((IfcParse::entity*)IFC4_types[702]); }
|
|
void Ifc4::IfcPresentationStyleAssignment::initialize(std::vector< ::Ifc4::IfcPresentationStyleSelect > v1_Styles) { set_attribute_value(0, cast_vector<express::Base>(v1_Styles)); }
|
|
|
|
// Function implementations for IfcProcedure
|
|
std::optional< ::Ifc4::IfcProcedureTypeEnum::Value > Ifc4::IfcProcedure::PredefinedType() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } return ::Ifc4::IfcProcedureTypeEnum::FromString(get_attribute_value(7)); }
|
|
void Ifc4::IfcProcedure::setPredefinedType(const std::optional< ::Ifc4::IfcProcedureTypeEnum::Value >& v) { if (v) {set_attribute_value(7, EnumerationReference(&::Ifc4::IfcProcedureTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(7);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcProcedure::Class() { return *((IfcParse::entity*)IFC4_types[705]); }
|
|
void Ifc4::IfcProcedure::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< std::string > v7_LongDescription, std::optional< ::Ifc4::IfcProcedureTypeEnum::Value > v8_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_LongDescription) {set_attribute_value(6, (*v7_LongDescription)); } if (v8_PredefinedType) {set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcProcedureTypeEnum::Class(),(size_t)*v8_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcProcedureType
|
|
::Ifc4::IfcProcedureTypeEnum::Value Ifc4::IfcProcedureType::PredefinedType() const { return ::Ifc4::IfcProcedureTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcProcedureType::setPredefinedType(const ::Ifc4::IfcProcedureTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcProcedureTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcProcedureType::Class() { return *((IfcParse::entity*)IFC4_types[706]); }
|
|
void Ifc4::IfcProcedureType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::string > v7_Identification, std::optional< std::string > v8_LongDescription, std::optional< std::string > v9_ProcessType, ::Ifc4::IfcProcedureTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_Identification) {set_attribute_value(6, (*v7_Identification)); } if (v8_LongDescription) {set_attribute_value(7, (*v8_LongDescription)); } if (v9_ProcessType) {set_attribute_value(8, (*v9_ProcessType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcProcedureTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcProcess
|
|
std::optional< std::string > Ifc4::IfcProcess::Identification() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcProcess::setIdentification(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< std::string > Ifc4::IfcProcess::LongDescription() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcProcess::setLongDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
|
|
std::vector<::Ifc4::IfcRelSequence> Ifc4::IfcProcess::IsPredecessorTo() const { return cast_vector<IfcRelSequence>(file()->getInverse(data()->id(), IFC4_types[839], 4)); }
|
|
std::vector<::Ifc4::IfcRelSequence> Ifc4::IfcProcess::IsSuccessorFrom() const { return cast_vector<IfcRelSequence>(file()->getInverse(data()->id(), IFC4_types[839], 5)); }
|
|
std::vector<::Ifc4::IfcRelAssignsToProcess> Ifc4::IfcProcess::OperatesOn() const { return cast_vector<IfcRelAssignsToProcess>(file()->getInverse(data()->id(), IFC4_types[803], 6)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcProcess::Class() { return *((IfcParse::entity*)IFC4_types[708]); }
|
|
void Ifc4::IfcProcess::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< std::string > v7_LongDescription) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_LongDescription) {set_attribute_value(6, (*v7_LongDescription)); } }
|
|
|
|
// Function implementations for IfcProduct
|
|
::Ifc4::IfcObjectPlacement Ifc4::IfcProduct::ObjectPlacement() const { if(get_attribute_value(5).isNull()) { return ::Ifc4::IfcObjectPlacement{}; } return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcObjectPlacement>(); }
|
|
void Ifc4::IfcProduct::setObjectPlacement(const ::Ifc4::IfcObjectPlacement& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
::Ifc4::IfcProductRepresentation Ifc4::IfcProduct::Representation() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcProductRepresentation{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcProductRepresentation>(); }
|
|
void Ifc4::IfcProduct::setRepresentation(const ::Ifc4::IfcProductRepresentation& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
std::vector<::Ifc4::IfcRelAssignsToProduct> Ifc4::IfcProduct::ReferencedBy() const { return cast_vector<IfcRelAssignsToProduct>(file()->getInverse(data()->id(), IFC4_types[804], 6)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcProduct::Class() { return *((IfcParse::entity*)IFC4_types[710]); }
|
|
void Ifc4::IfcProduct::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); }
|
|
|
|
// Function implementations for IfcProductDefinitionShape
|
|
|
|
std::vector<::Ifc4::IfcProduct> Ifc4::IfcProductDefinitionShape::ShapeOfProduct() const { return cast_vector<IfcProduct>(file()->getInverse(data()->id(), IFC4_types[710], 6)); }
|
|
std::vector<::Ifc4::IfcShapeAspect> Ifc4::IfcProductDefinitionShape::HasShapeAspects() const { return cast_vector<IfcShapeAspect>(file()->getInverse(data()->id(), IFC4_types[890], 4)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcProductDefinitionShape::Class() { return *((IfcParse::entity*)IFC4_types[711]); }
|
|
void Ifc4::IfcProductDefinitionShape::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, std::vector< ::Ifc4::IfcRepresentation > v3_Representations) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, cast_vector<express::Base>(v3_Representations)); }
|
|
|
|
// Function implementations for IfcProductRepresentation
|
|
std::optional< std::string > Ifc4::IfcProductRepresentation::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcProductRepresentation::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< std::string > Ifc4::IfcProductRepresentation::Description() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcProductRepresentation::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::vector< ::Ifc4::IfcRepresentation > Ifc4::IfcProductRepresentation::Representations() const { std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcRepresentation>(es); }
|
|
void Ifc4::IfcProductRepresentation::setRepresentations(const std::vector< ::Ifc4::IfcRepresentation >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcProductRepresentation::Class() { return *((IfcParse::entity*)IFC4_types[712]); }
|
|
void Ifc4::IfcProductRepresentation::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, std::vector< ::Ifc4::IfcRepresentation > v3_Representations) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, cast_vector<express::Base>(v3_Representations)); }
|
|
|
|
// Function implementations for IfcProfileDef
|
|
::Ifc4::IfcProfileTypeEnum::Value Ifc4::IfcProfileDef::ProfileType() const { return ::Ifc4::IfcProfileTypeEnum::FromString(get_attribute_value(0)); }
|
|
void Ifc4::IfcProfileDef::setProfileType(const ::Ifc4::IfcProfileTypeEnum::Value& v) { set_attribute_value(0, EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< std::string > Ifc4::IfcProfileDef::ProfileName() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcProfileDef::setProfileName(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
|
|
std::vector<::Ifc4::IfcExternalReferenceRelationship> Ifc4::IfcProfileDef::HasExternalReference() const { return cast_vector<IfcExternalReferenceRelationship>(file()->getInverse(data()->id(), IFC4_types[380], 3)); }
|
|
std::vector<::Ifc4::IfcProfileProperties> Ifc4::IfcProfileDef::HasProperties() const { return cast_vector<IfcProfileProperties>(file()->getInverse(data()->id(), IFC4_types[716], 3)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[715]); }
|
|
void Ifc4::IfcProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); } }
|
|
|
|
// Function implementations for IfcProfileProperties
|
|
::Ifc4::IfcProfileDef Ifc4::IfcProfileProperties::ProfileDefinition() const { return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcProfileDef>(); }
|
|
void Ifc4::IfcProfileProperties::setProfileDefinition(const ::Ifc4::IfcProfileDef& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcProfileProperties::Class() { return *((IfcParse::entity*)IFC4_types[716]); }
|
|
void Ifc4::IfcProfileProperties::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, std::vector< ::Ifc4::IfcProperty > v3_Properties, ::Ifc4::IfcProfileDef v4_ProfileDefinition) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, cast_vector<express::Base>(v3_Properties));set_attribute_value(3, (v4_ProfileDefinition)); }
|
|
|
|
// Function implementations for IfcProject
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcProject::Class() { return *((IfcParse::entity*)IFC4_types[718]); }
|
|
void Ifc4::IfcProject::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_LongName, std::optional< std::string > v7_Phase, std::optional< std::vector< ::Ifc4::IfcRepresentationContext > > v8_RepresentationContexts, ::Ifc4::IfcUnitAssignment v9_UnitsInContext) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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)); } if (v8_RepresentationContexts) {set_attribute_value(7, cast_vector<express::Base>(*v8_RepresentationContexts)); }set_attribute_value(8, (v9_UnitsInContext)); }
|
|
|
|
// Function implementations for IfcProjectLibrary
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcProjectLibrary::Class() { return *((IfcParse::entity*)IFC4_types[723]); }
|
|
void Ifc4::IfcProjectLibrary::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_LongName, std::optional< std::string > v7_Phase, std::optional< std::vector< ::Ifc4::IfcRepresentationContext > > v8_RepresentationContexts, ::Ifc4::IfcUnitAssignment v9_UnitsInContext) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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)); } if (v8_RepresentationContexts) {set_attribute_value(7, cast_vector<express::Base>(*v8_RepresentationContexts)); }set_attribute_value(8, (v9_UnitsInContext)); }
|
|
|
|
// Function implementations for IfcProjectOrder
|
|
std::optional< ::Ifc4::IfcProjectOrderTypeEnum::Value > Ifc4::IfcProjectOrder::PredefinedType() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } return ::Ifc4::IfcProjectOrderTypeEnum::FromString(get_attribute_value(6)); }
|
|
void Ifc4::IfcProjectOrder::setPredefinedType(const std::optional< ::Ifc4::IfcProjectOrderTypeEnum::Value >& v) { if (v) {set_attribute_value(6, EnumerationReference(&::Ifc4::IfcProjectOrderTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(6);} }
|
|
std::optional< std::string > Ifc4::IfcProjectOrder::Status() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::string v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcProjectOrder::setStatus(const std::optional< std::string >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< std::string > Ifc4::IfcProjectOrder::LongDescription() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcProjectOrder::setLongDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcProjectOrder::Class() { return *((IfcParse::entity*)IFC4_types[724]); }
|
|
void Ifc4::IfcProjectOrder::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< ::Ifc4::IfcProjectOrderTypeEnum::Value > v7_PredefinedType, std::optional< std::string > v8_Status, std::optional< std::string > v9_LongDescription) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_PredefinedType) {set_attribute_value(6, (EnumerationReference(&::Ifc4::IfcProjectOrderTypeEnum::Class(),(size_t)*v7_PredefinedType))); } if (v8_Status) {set_attribute_value(7, (*v8_Status)); } if (v9_LongDescription) {set_attribute_value(8, (*v9_LongDescription)); } }
|
|
|
|
// Function implementations for IfcProjectedCRS
|
|
std::optional< std::string > Ifc4::IfcProjectedCRS::MapProjection() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcProjectedCRS::setMapProjection(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcProjectedCRS::MapZone() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcProjectedCRS::setMapZone(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
::Ifc4::IfcNamedUnit Ifc4::IfcProjectedCRS::MapUnit() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcNamedUnit{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcNamedUnit>(); }
|
|
void Ifc4::IfcProjectedCRS::setMapUnit(const ::Ifc4::IfcNamedUnit& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcProjectedCRS::Class() { return *((IfcParse::entity*)IFC4_types[719]); }
|
|
void Ifc4::IfcProjectedCRS::initialize(std::string v1_Name, std::optional< std::string > v2_Description, std::optional< std::string > v3_GeodeticDatum, std::optional< std::string > v4_VerticalDatum, std::optional< std::string > v5_MapProjection, std::optional< std::string > v6_MapZone, ::Ifc4::IfcNamedUnit v7_MapUnit) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); } if (v3_GeodeticDatum) {set_attribute_value(2, (*v3_GeodeticDatum)); } if (v4_VerticalDatum) {set_attribute_value(3, (*v4_VerticalDatum)); } if (v5_MapProjection) {set_attribute_value(4, (*v5_MapProjection)); } if (v6_MapZone) {set_attribute_value(5, (*v6_MapZone)); }set_attribute_value(6, (v7_MapUnit)); }
|
|
|
|
// Function implementations for IfcProjectionElement
|
|
std::optional< ::Ifc4::IfcProjectionElementTypeEnum::Value > Ifc4::IfcProjectionElement::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcProjectionElementTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcProjectionElement::setPredefinedType(const std::optional< ::Ifc4::IfcProjectionElementTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcProjectionElementTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcProjectionElement::Class() { return *((IfcParse::entity*)IFC4_types[721]); }
|
|
void Ifc4::IfcProjectionElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcProjectionElementTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcProjectionElementTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcProperty
|
|
std::string Ifc4::IfcProperty::Name() const { std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcProperty::setName(const std::string& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< std::string > Ifc4::IfcProperty::Description() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcProperty::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
|
|
std::vector<::Ifc4::IfcPropertySet> Ifc4::IfcProperty::PartOfPset() const { return cast_vector<IfcPropertySet>(file()->getInverse(data()->id(), IFC4_types[735], 4)); }
|
|
std::vector<::Ifc4::IfcPropertyDependencyRelationship> Ifc4::IfcProperty::PropertyForDependance() const { return cast_vector<IfcPropertyDependencyRelationship>(file()->getInverse(data()->id(), IFC4_types[730], 2)); }
|
|
std::vector<::Ifc4::IfcPropertyDependencyRelationship> Ifc4::IfcProperty::PropertyDependsOn() const { return cast_vector<IfcPropertyDependencyRelationship>(file()->getInverse(data()->id(), IFC4_types[730], 3)); }
|
|
std::vector<::Ifc4::IfcComplexProperty> Ifc4::IfcProperty::PartOfComplex() const { return cast_vector<IfcComplexProperty>(file()->getInverse(data()->id(), IFC4_types[162], 3)); }
|
|
std::vector<::Ifc4::IfcResourceConstraintRelationship> Ifc4::IfcProperty::HasConstraints() const { return cast_vector<IfcResourceConstraintRelationship>(file()->getInverse(data()->id(), IFC4_types[852], 3)); }
|
|
std::vector<::Ifc4::IfcResourceApprovalRelationship> Ifc4::IfcProperty::HasApprovals() const { return cast_vector<IfcResourceApprovalRelationship>(file()->getInverse(data()->id(), IFC4_types[851], 2)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcProperty::Class() { return *((IfcParse::entity*)IFC4_types[726]); }
|
|
void Ifc4::IfcProperty::initialize(std::string v1_Name, std::optional< std::string > v2_Description) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); } }
|
|
|
|
// Function implementations for IfcPropertyAbstraction
|
|
|
|
std::vector<::Ifc4::IfcExternalReferenceRelationship> Ifc4::IfcPropertyAbstraction::HasExternalReferences() const { return cast_vector<IfcExternalReferenceRelationship>(file()->getInverse(data()->id(), IFC4_types[380], 3)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcPropertyAbstraction::Class() { return *((IfcParse::entity*)IFC4_types[727]); }
|
|
void Ifc4::IfcPropertyAbstraction::initialize() { }
|
|
|
|
// Function implementations for IfcPropertyBoundedValue
|
|
::Ifc4::IfcValue Ifc4::IfcPropertyBoundedValue::UpperBoundValue() const { if(get_attribute_value(2).isNull()) { return ::Ifc4::IfcValue{}; } return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcValue>(); }
|
|
void Ifc4::IfcPropertyBoundedValue::setUpperBoundValue(const ::Ifc4::IfcValue& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcValue Ifc4::IfcPropertyBoundedValue::LowerBoundValue() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcValue{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcValue>(); }
|
|
void Ifc4::IfcPropertyBoundedValue::setLowerBoundValue(const ::Ifc4::IfcValue& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
::Ifc4::IfcUnit Ifc4::IfcPropertyBoundedValue::Unit() const { if(get_attribute_value(4).isNull()) { return ::Ifc4::IfcUnit{}; } return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcUnit>(); }
|
|
void Ifc4::IfcPropertyBoundedValue::setUnit(const ::Ifc4::IfcUnit& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcValue Ifc4::IfcPropertyBoundedValue::SetPointValue() const { if(get_attribute_value(5).isNull()) { return ::Ifc4::IfcValue{}; } return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcValue>(); }
|
|
void Ifc4::IfcPropertyBoundedValue::setSetPointValue(const ::Ifc4::IfcValue& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPropertyBoundedValue::Class() { return *((IfcParse::entity*)IFC4_types[728]); }
|
|
void Ifc4::IfcPropertyBoundedValue::initialize(std::string v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcValue v3_UpperBoundValue, ::Ifc4::IfcValue v4_LowerBoundValue, ::Ifc4::IfcUnit v5_Unit, ::Ifc4::IfcValue v6_SetPointValue) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_UpperBoundValue));set_attribute_value(3, (v4_LowerBoundValue));set_attribute_value(4, (v5_Unit));set_attribute_value(5, (v6_SetPointValue)); }
|
|
|
|
// Function implementations for IfcPropertyDefinition
|
|
|
|
std::vector<::Ifc4::IfcRelDeclares> Ifc4::IfcPropertyDefinition::HasContext() const { return cast_vector<IfcRelDeclares>(file()->getInverse(data()->id(), IFC4_types[826], 5)); }
|
|
std::vector<::Ifc4::IfcRelAssociates> Ifc4::IfcPropertyDefinition::HasAssociations() const { return cast_vector<IfcRelAssociates>(file()->getInverse(data()->id(), IFC4_types[806], 4)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcPropertyDefinition::Class() { return *((IfcParse::entity*)IFC4_types[729]); }
|
|
void Ifc4::IfcPropertyDefinition::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } }
|
|
|
|
// Function implementations for IfcPropertyDependencyRelationship
|
|
::Ifc4::IfcProperty Ifc4::IfcPropertyDependencyRelationship::DependingProperty() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcProperty>(); }
|
|
void Ifc4::IfcPropertyDependencyRelationship::setDependingProperty(const ::Ifc4::IfcProperty& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcProperty Ifc4::IfcPropertyDependencyRelationship::DependantProperty() const { return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcProperty>(); }
|
|
void Ifc4::IfcPropertyDependencyRelationship::setDependantProperty(const ::Ifc4::IfcProperty& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< std::string > Ifc4::IfcPropertyDependencyRelationship::Expression() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcPropertyDependencyRelationship::setExpression(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPropertyDependencyRelationship::Class() { return *((IfcParse::entity*)IFC4_types[730]); }
|
|
void Ifc4::IfcPropertyDependencyRelationship::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcProperty v3_DependingProperty, ::Ifc4::IfcProperty v4_DependantProperty, std::optional< std::string > v5_Expression) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_DependingProperty));set_attribute_value(3, (v4_DependantProperty)); if (v5_Expression) {set_attribute_value(4, (*v5_Expression)); } }
|
|
|
|
// Function implementations for IfcPropertyEnumeratedValue
|
|
std::optional< std::vector< ::Ifc4::IfcValue > > Ifc4::IfcPropertyEnumeratedValue::EnumerationValues() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcValue>(es); }
|
|
void Ifc4::IfcPropertyEnumeratedValue::setEnumerationValues(const std::optional< std::vector< ::Ifc4::IfcValue > >& v) { if (v) {set_attribute_value(2, cast_vector<express::Base>(*v));} else {unset_attribute_value(2);} }
|
|
::Ifc4::IfcPropertyEnumeration Ifc4::IfcPropertyEnumeratedValue::EnumerationReference() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcPropertyEnumeration{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcPropertyEnumeration>(); }
|
|
void Ifc4::IfcPropertyEnumeratedValue::setEnumerationReference(const ::Ifc4::IfcPropertyEnumeration& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPropertyEnumeratedValue::Class() { return *((IfcParse::entity*)IFC4_types[731]); }
|
|
void Ifc4::IfcPropertyEnumeratedValue::initialize(std::string v1_Name, std::optional< std::string > v2_Description, std::optional< std::vector< ::Ifc4::IfcValue > > v3_EnumerationValues, ::Ifc4::IfcPropertyEnumeration v4_EnumerationReference) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); } if (v3_EnumerationValues) {set_attribute_value(2, cast_vector<express::Base>(*v3_EnumerationValues)); }set_attribute_value(3, (v4_EnumerationReference)); }
|
|
|
|
// Function implementations for IfcPropertyEnumeration
|
|
std::string Ifc4::IfcPropertyEnumeration::Name() const { std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcPropertyEnumeration::setName(const std::string& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::vector< ::Ifc4::IfcValue > Ifc4::IfcPropertyEnumeration::EnumerationValues() const { std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcValue>(es); }
|
|
void Ifc4::IfcPropertyEnumeration::setEnumerationValues(const std::vector< ::Ifc4::IfcValue >& v) { set_attribute_value(1, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcUnit Ifc4::IfcPropertyEnumeration::Unit() const { if(get_attribute_value(2).isNull()) { return ::Ifc4::IfcUnit{}; } return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcUnit>(); }
|
|
void Ifc4::IfcPropertyEnumeration::setUnit(const ::Ifc4::IfcUnit& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPropertyEnumeration::Class() { return *((IfcParse::entity*)IFC4_types[732]); }
|
|
void Ifc4::IfcPropertyEnumeration::initialize(std::string v1_Name, std::vector< ::Ifc4::IfcValue > v2_EnumerationValues, ::Ifc4::IfcUnit v3_Unit) { set_attribute_value(0, (v1_Name));set_attribute_value(1, cast_vector<express::Base>(v2_EnumerationValues));set_attribute_value(2, (v3_Unit)); }
|
|
|
|
// Function implementations for IfcPropertyListValue
|
|
std::optional< std::vector< ::Ifc4::IfcValue > > Ifc4::IfcPropertyListValue::ListValues() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcValue>(es); }
|
|
void Ifc4::IfcPropertyListValue::setListValues(const std::optional< std::vector< ::Ifc4::IfcValue > >& v) { if (v) {set_attribute_value(2, cast_vector<express::Base>(*v));} else {unset_attribute_value(2);} }
|
|
::Ifc4::IfcUnit Ifc4::IfcPropertyListValue::Unit() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcUnit{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcUnit>(); }
|
|
void Ifc4::IfcPropertyListValue::setUnit(const ::Ifc4::IfcUnit& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPropertyListValue::Class() { return *((IfcParse::entity*)IFC4_types[733]); }
|
|
void Ifc4::IfcPropertyListValue::initialize(std::string v1_Name, std::optional< std::string > v2_Description, std::optional< std::vector< ::Ifc4::IfcValue > > v3_ListValues, ::Ifc4::IfcUnit v4_Unit) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); } if (v3_ListValues) {set_attribute_value(2, cast_vector<express::Base>(*v3_ListValues)); }set_attribute_value(3, (v4_Unit)); }
|
|
|
|
// Function implementations for IfcPropertyReferenceValue
|
|
std::optional< std::string > Ifc4::IfcPropertyReferenceValue::UsageName() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcPropertyReferenceValue::setUsageName(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
::Ifc4::IfcObjectReferenceSelect Ifc4::IfcPropertyReferenceValue::PropertyReference() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcObjectReferenceSelect{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcObjectReferenceSelect>(); }
|
|
void Ifc4::IfcPropertyReferenceValue::setPropertyReference(const ::Ifc4::IfcObjectReferenceSelect& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPropertyReferenceValue::Class() { return *((IfcParse::entity*)IFC4_types[734]); }
|
|
void Ifc4::IfcPropertyReferenceValue::initialize(std::string v1_Name, std::optional< std::string > v2_Description, std::optional< std::string > v3_UsageName, ::Ifc4::IfcObjectReferenceSelect v4_PropertyReference) { 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)); }
|
|
|
|
// Function implementations for IfcPropertySet
|
|
std::vector< ::Ifc4::IfcProperty > Ifc4::IfcPropertySet::HasProperties() const { std::vector<express::Base> es = get_attribute_value(4); return cast_vector<::Ifc4::IfcProperty>(es); }
|
|
void Ifc4::IfcPropertySet::setHasProperties(const std::vector< ::Ifc4::IfcProperty >& v) { set_attribute_value(4, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPropertySet::Class() { return *((IfcParse::entity*)IFC4_types[735]); }
|
|
void Ifc4::IfcPropertySet::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcProperty > v5_HasProperties) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_HasProperties)); }
|
|
|
|
// Function implementations for IfcPropertySetDefinition
|
|
|
|
std::vector<::Ifc4::IfcTypeObject> Ifc4::IfcPropertySetDefinition::DefinesType() const { return cast_vector<IfcTypeObject>(file()->getInverse(data()->id(), IFC4_types[1106], 5)); }
|
|
std::vector<::Ifc4::IfcRelDefinesByTemplate> Ifc4::IfcPropertySetDefinition::IsDefinedBy() const { return cast_vector<IfcRelDefinesByTemplate>(file()->getInverse(data()->id(), IFC4_types[831], 4)); }
|
|
std::vector<::Ifc4::IfcRelDefinesByProperties> Ifc4::IfcPropertySetDefinition::DefinesOccurrence() const { return cast_vector<IfcRelDefinesByProperties>(file()->getInverse(data()->id(), IFC4_types[830], 5)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcPropertySetDefinition::Class() { return *((IfcParse::entity*)IFC4_types[736]); }
|
|
void Ifc4::IfcPropertySetDefinition::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } }
|
|
|
|
// Function implementations for IfcPropertySetTemplate
|
|
std::optional< ::Ifc4::IfcPropertySetTemplateTypeEnum::Value > Ifc4::IfcPropertySetTemplate::TemplateType() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } return ::Ifc4::IfcPropertySetTemplateTypeEnum::FromString(get_attribute_value(4)); }
|
|
void Ifc4::IfcPropertySetTemplate::setTemplateType(const std::optional< ::Ifc4::IfcPropertySetTemplateTypeEnum::Value >& v) { if (v) {set_attribute_value(4, EnumerationReference(&::Ifc4::IfcPropertySetTemplateTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcPropertySetTemplate::ApplicableEntity() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcPropertySetTemplate::setApplicableEntity(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::vector< ::Ifc4::IfcPropertyTemplate > Ifc4::IfcPropertySetTemplate::HasPropertyTemplates() const { std::vector<express::Base> es = get_attribute_value(6); return cast_vector<::Ifc4::IfcPropertyTemplate>(es); }
|
|
void Ifc4::IfcPropertySetTemplate::setHasPropertyTemplates(const std::vector< ::Ifc4::IfcPropertyTemplate >& v) { set_attribute_value(6, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(6); }
|
|
|
|
std::vector<::Ifc4::IfcRelDefinesByTemplate> Ifc4::IfcPropertySetTemplate::Defines() const { return cast_vector<IfcRelDefinesByTemplate>(file()->getInverse(data()->id(), IFC4_types[831], 5)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcPropertySetTemplate::Class() { return *((IfcParse::entity*)IFC4_types[739]); }
|
|
void Ifc4::IfcPropertySetTemplate::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< ::Ifc4::IfcPropertySetTemplateTypeEnum::Value > v5_TemplateType, std::optional< std::string > v6_ApplicableEntity, std::vector< ::Ifc4::IfcPropertyTemplate > v7_HasPropertyTemplates) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_TemplateType) {set_attribute_value(4, (EnumerationReference(&::Ifc4::IfcPropertySetTemplateTypeEnum::Class(),(size_t)*v5_TemplateType))); } if (v6_ApplicableEntity) {set_attribute_value(5, (*v6_ApplicableEntity)); }set_attribute_value(6, cast_vector<express::Base>(v7_HasPropertyTemplates)); }
|
|
|
|
// Function implementations for IfcPropertySingleValue
|
|
::Ifc4::IfcValue Ifc4::IfcPropertySingleValue::NominalValue() const { if(get_attribute_value(2).isNull()) { return ::Ifc4::IfcValue{}; } return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcValue>(); }
|
|
void Ifc4::IfcPropertySingleValue::setNominalValue(const ::Ifc4::IfcValue& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcUnit Ifc4::IfcPropertySingleValue::Unit() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcUnit{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcUnit>(); }
|
|
void Ifc4::IfcPropertySingleValue::setUnit(const ::Ifc4::IfcUnit& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPropertySingleValue::Class() { return *((IfcParse::entity*)IFC4_types[741]); }
|
|
void Ifc4::IfcPropertySingleValue::initialize(std::string v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcValue v3_NominalValue, ::Ifc4::IfcUnit v4_Unit) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_NominalValue));set_attribute_value(3, (v4_Unit)); }
|
|
|
|
// Function implementations for IfcPropertyTableValue
|
|
std::optional< std::vector< ::Ifc4::IfcValue > > Ifc4::IfcPropertyTableValue::DefiningValues() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcValue>(es); }
|
|
void Ifc4::IfcPropertyTableValue::setDefiningValues(const std::optional< std::vector< ::Ifc4::IfcValue > >& v) { if (v) {set_attribute_value(2, cast_vector<express::Base>(*v));} else {unset_attribute_value(2);} }
|
|
std::optional< std::vector< ::Ifc4::IfcValue > > Ifc4::IfcPropertyTableValue::DefinedValues() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(3); return cast_vector<::Ifc4::IfcValue>(es); }
|
|
void Ifc4::IfcPropertyTableValue::setDefinedValues(const std::optional< std::vector< ::Ifc4::IfcValue > >& v) { if (v) {set_attribute_value(3, cast_vector<express::Base>(*v));} else {unset_attribute_value(3);} }
|
|
std::optional< std::string > Ifc4::IfcPropertyTableValue::Expression() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcPropertyTableValue::setExpression(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
::Ifc4::IfcUnit Ifc4::IfcPropertyTableValue::DefiningUnit() const { if(get_attribute_value(5).isNull()) { return ::Ifc4::IfcUnit{}; } return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcUnit>(); }
|
|
void Ifc4::IfcPropertyTableValue::setDefiningUnit(const ::Ifc4::IfcUnit& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
::Ifc4::IfcUnit Ifc4::IfcPropertyTableValue::DefinedUnit() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcUnit{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcUnit>(); }
|
|
void Ifc4::IfcPropertyTableValue::setDefinedUnit(const ::Ifc4::IfcUnit& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
std::optional< ::Ifc4::IfcCurveInterpolationEnum::Value > Ifc4::IfcPropertyTableValue::CurveInterpolation() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } return ::Ifc4::IfcCurveInterpolationEnum::FromString(get_attribute_value(7)); }
|
|
void Ifc4::IfcPropertyTableValue::setCurveInterpolation(const std::optional< ::Ifc4::IfcCurveInterpolationEnum::Value >& v) { if (v) {set_attribute_value(7, EnumerationReference(&::Ifc4::IfcCurveInterpolationEnum::Class(), (size_t) *v));} else {unset_attribute_value(7);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPropertyTableValue::Class() { return *((IfcParse::entity*)IFC4_types[742]); }
|
|
void Ifc4::IfcPropertyTableValue::initialize(std::string v1_Name, std::optional< std::string > v2_Description, std::optional< std::vector< ::Ifc4::IfcValue > > v3_DefiningValues, std::optional< std::vector< ::Ifc4::IfcValue > > v4_DefinedValues, std::optional< std::string > v5_Expression, ::Ifc4::IfcUnit v6_DefiningUnit, ::Ifc4::IfcUnit v7_DefinedUnit, std::optional< ::Ifc4::IfcCurveInterpolationEnum::Value > v8_CurveInterpolation) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); } if (v3_DefiningValues) {set_attribute_value(2, cast_vector<express::Base>(*v3_DefiningValues)); } if (v4_DefinedValues) {set_attribute_value(3, cast_vector<express::Base>(*v4_DefinedValues)); } if (v5_Expression) {set_attribute_value(4, (*v5_Expression)); }set_attribute_value(5, (v6_DefiningUnit));set_attribute_value(6, (v7_DefinedUnit)); if (v8_CurveInterpolation) {set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcCurveInterpolationEnum::Class(),(size_t)*v8_CurveInterpolation))); } }
|
|
|
|
// Function implementations for IfcPropertyTemplate
|
|
|
|
std::vector<::Ifc4::IfcComplexPropertyTemplate> Ifc4::IfcPropertyTemplate::PartOfComplexTemplate() const { return cast_vector<IfcComplexPropertyTemplate>(file()->getInverse(data()->id(), IFC4_types[163], 6)); }
|
|
std::vector<::Ifc4::IfcPropertySetTemplate> Ifc4::IfcPropertyTemplate::PartOfPsetTemplate() const { return cast_vector<IfcPropertySetTemplate>(file()->getInverse(data()->id(), IFC4_types[739], 6)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcPropertyTemplate::Class() { return *((IfcParse::entity*)IFC4_types[743]); }
|
|
void Ifc4::IfcPropertyTemplate::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } }
|
|
|
|
// Function implementations for IfcPropertyTemplateDefinition
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPropertyTemplateDefinition::Class() { return *((IfcParse::entity*)IFC4_types[744]); }
|
|
void Ifc4::IfcPropertyTemplateDefinition::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } }
|
|
|
|
// Function implementations for IfcProtectiveDevice
|
|
std::optional< ::Ifc4::IfcProtectiveDeviceTypeEnum::Value > Ifc4::IfcProtectiveDevice::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcProtectiveDeviceTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcProtectiveDevice::setPredefinedType(const std::optional< ::Ifc4::IfcProtectiveDeviceTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcProtectiveDeviceTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcProtectiveDevice::Class() { return *((IfcParse::entity*)IFC4_types[745]); }
|
|
void Ifc4::IfcProtectiveDevice::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcProtectiveDeviceTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcProtectiveDeviceTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcProtectiveDeviceTrippingUnit
|
|
std::optional< ::Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::Value > Ifc4::IfcProtectiveDeviceTrippingUnit::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcProtectiveDeviceTrippingUnit::setPredefinedType(const std::optional< ::Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcProtectiveDeviceTrippingUnit::Class() { return *((IfcParse::entity*)IFC4_types[746]); }
|
|
void Ifc4::IfcProtectiveDeviceTrippingUnit::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcProtectiveDeviceTrippingUnitType
|
|
::Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::Value Ifc4::IfcProtectiveDeviceTrippingUnitType::PredefinedType() const { return ::Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcProtectiveDeviceTrippingUnitType::setPredefinedType(const ::Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcProtectiveDeviceTrippingUnitType::Class() { return *((IfcParse::entity*)IFC4_types[747]); }
|
|
void Ifc4::IfcProtectiveDeviceTrippingUnitType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcProtectiveDeviceTrippingUnitTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcProtectiveDeviceType
|
|
::Ifc4::IfcProtectiveDeviceTypeEnum::Value Ifc4::IfcProtectiveDeviceType::PredefinedType() const { return ::Ifc4::IfcProtectiveDeviceTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcProtectiveDeviceType::setPredefinedType(const ::Ifc4::IfcProtectiveDeviceTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcProtectiveDeviceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcProtectiveDeviceType::Class() { return *((IfcParse::entity*)IFC4_types[749]); }
|
|
void Ifc4::IfcProtectiveDeviceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcProtectiveDeviceTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcProtectiveDeviceTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcProxy
|
|
::Ifc4::IfcObjectTypeEnum::Value Ifc4::IfcProxy::ProxyType() const { return ::Ifc4::IfcObjectTypeEnum::FromString(get_attribute_value(7)); }
|
|
void Ifc4::IfcProxy::setProxyType(const ::Ifc4::IfcObjectTypeEnum::Value& v) { set_attribute_value(7, EnumerationReference(&::Ifc4::IfcObjectTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }
|
|
std::optional< std::string > Ifc4::IfcProxy::Tag() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcProxy::setTag(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcProxy::Class() { return *((IfcParse::entity*)IFC4_types[751]); }
|
|
void Ifc4::IfcProxy::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcObjectTypeEnum::Value v8_ProxyType, std::optional< std::string > v9_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcObjectTypeEnum::Class(),(size_t)v8_ProxyType))); if (v9_Tag) {set_attribute_value(8, (*v9_Tag)); } }
|
|
|
|
// Function implementations for IfcPump
|
|
std::optional< ::Ifc4::IfcPumpTypeEnum::Value > Ifc4::IfcPump::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcPumpTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcPump::setPredefinedType(const std::optional< ::Ifc4::IfcPumpTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcPumpTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPump::Class() { return *((IfcParse::entity*)IFC4_types[752]); }
|
|
void Ifc4::IfcPump::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcPumpTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcPumpTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcPumpType
|
|
::Ifc4::IfcPumpTypeEnum::Value Ifc4::IfcPumpType::PredefinedType() const { return ::Ifc4::IfcPumpTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcPumpType::setPredefinedType(const ::Ifc4::IfcPumpTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcPumpTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcPumpType::Class() { return *((IfcParse::entity*)IFC4_types[753]); }
|
|
void Ifc4::IfcPumpType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcPumpTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcPumpTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcQuantityArea
|
|
double Ifc4::IfcQuantityArea::AreaValue() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcQuantityArea::setAreaValue(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< std::string > Ifc4::IfcQuantityArea::Formula() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcQuantityArea::setFormula(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcQuantityArea::Class() { return *((IfcParse::entity*)IFC4_types[755]); }
|
|
void Ifc4::IfcQuantityArea::initialize(std::string v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcNamedUnit v3_Unit, double v4_AreaValue, std::optional< std::string > v5_Formula) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_Unit));set_attribute_value(3, (v4_AreaValue)); if (v5_Formula) {set_attribute_value(4, (*v5_Formula)); } }
|
|
|
|
// Function implementations for IfcQuantityCount
|
|
double Ifc4::IfcQuantityCount::CountValue() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcQuantityCount::setCountValue(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< std::string > Ifc4::IfcQuantityCount::Formula() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcQuantityCount::setFormula(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcQuantityCount::Class() { return *((IfcParse::entity*)IFC4_types[756]); }
|
|
void Ifc4::IfcQuantityCount::initialize(std::string v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcNamedUnit v3_Unit, double v4_CountValue, std::optional< std::string > v5_Formula) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_Unit));set_attribute_value(3, (v4_CountValue)); if (v5_Formula) {set_attribute_value(4, (*v5_Formula)); } }
|
|
|
|
// Function implementations for IfcQuantityLength
|
|
double Ifc4::IfcQuantityLength::LengthValue() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcQuantityLength::setLengthValue(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< std::string > Ifc4::IfcQuantityLength::Formula() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcQuantityLength::setFormula(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcQuantityLength::Class() { return *((IfcParse::entity*)IFC4_types[757]); }
|
|
void Ifc4::IfcQuantityLength::initialize(std::string v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcNamedUnit v3_Unit, double v4_LengthValue, std::optional< std::string > v5_Formula) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_Unit));set_attribute_value(3, (v4_LengthValue)); if (v5_Formula) {set_attribute_value(4, (*v5_Formula)); } }
|
|
|
|
// Function implementations for IfcQuantitySet
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcQuantitySet::Class() { return *((IfcParse::entity*)IFC4_types[758]); }
|
|
void Ifc4::IfcQuantitySet::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } }
|
|
|
|
// Function implementations for IfcQuantityTime
|
|
double Ifc4::IfcQuantityTime::TimeValue() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcQuantityTime::setTimeValue(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< std::string > Ifc4::IfcQuantityTime::Formula() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcQuantityTime::setFormula(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcQuantityTime::Class() { return *((IfcParse::entity*)IFC4_types[759]); }
|
|
void Ifc4::IfcQuantityTime::initialize(std::string v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcNamedUnit v3_Unit, double v4_TimeValue, std::optional< std::string > v5_Formula) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_Unit));set_attribute_value(3, (v4_TimeValue)); if (v5_Formula) {set_attribute_value(4, (*v5_Formula)); } }
|
|
|
|
// Function implementations for IfcQuantityVolume
|
|
double Ifc4::IfcQuantityVolume::VolumeValue() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcQuantityVolume::setVolumeValue(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< std::string > Ifc4::IfcQuantityVolume::Formula() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcQuantityVolume::setFormula(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcQuantityVolume::Class() { return *((IfcParse::entity*)IFC4_types[760]); }
|
|
void Ifc4::IfcQuantityVolume::initialize(std::string v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcNamedUnit v3_Unit, double v4_VolumeValue, std::optional< std::string > v5_Formula) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_Unit));set_attribute_value(3, (v4_VolumeValue)); if (v5_Formula) {set_attribute_value(4, (*v5_Formula)); } }
|
|
|
|
// Function implementations for IfcQuantityWeight
|
|
double Ifc4::IfcQuantityWeight::WeightValue() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcQuantityWeight::setWeightValue(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< std::string > Ifc4::IfcQuantityWeight::Formula() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcQuantityWeight::setFormula(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcQuantityWeight::Class() { return *((IfcParse::entity*)IFC4_types[761]); }
|
|
void Ifc4::IfcQuantityWeight::initialize(std::string v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcNamedUnit v3_Unit, double v4_WeightValue, std::optional< std::string > v5_Formula) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_Unit));set_attribute_value(3, (v4_WeightValue)); if (v5_Formula) {set_attribute_value(4, (*v5_Formula)); } }
|
|
|
|
// Function implementations for IfcRailing
|
|
std::optional< ::Ifc4::IfcRailingTypeEnum::Value > Ifc4::IfcRailing::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcRailingTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcRailing::setPredefinedType(const std::optional< ::Ifc4::IfcRailingTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcRailingTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRailing::Class() { return *((IfcParse::entity*)IFC4_types[763]); }
|
|
void Ifc4::IfcRailing::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcRailingTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcRailingTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcRailingType
|
|
::Ifc4::IfcRailingTypeEnum::Value Ifc4::IfcRailingType::PredefinedType() const { return ::Ifc4::IfcRailingTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcRailingType::setPredefinedType(const ::Ifc4::IfcRailingTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcRailingTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRailingType::Class() { return *((IfcParse::entity*)IFC4_types[764]); }
|
|
void Ifc4::IfcRailingType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcRailingTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcRailingTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcRamp
|
|
std::optional< ::Ifc4::IfcRampTypeEnum::Value > Ifc4::IfcRamp::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcRampTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcRamp::setPredefinedType(const std::optional< ::Ifc4::IfcRampTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcRampTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRamp::Class() { return *((IfcParse::entity*)IFC4_types[766]); }
|
|
void Ifc4::IfcRamp::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcRampTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcRampTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcRampFlight
|
|
std::optional< ::Ifc4::IfcRampFlightTypeEnum::Value > Ifc4::IfcRampFlight::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcRampFlightTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcRampFlight::setPredefinedType(const std::optional< ::Ifc4::IfcRampFlightTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcRampFlightTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRampFlight::Class() { return *((IfcParse::entity*)IFC4_types[767]); }
|
|
void Ifc4::IfcRampFlight::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcRampFlightTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcRampFlightTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcRampFlightType
|
|
::Ifc4::IfcRampFlightTypeEnum::Value Ifc4::IfcRampFlightType::PredefinedType() const { return ::Ifc4::IfcRampFlightTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcRampFlightType::setPredefinedType(const ::Ifc4::IfcRampFlightTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcRampFlightTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRampFlightType::Class() { return *((IfcParse::entity*)IFC4_types[768]); }
|
|
void Ifc4::IfcRampFlightType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcRampFlightTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcRampFlightTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcRampType
|
|
::Ifc4::IfcRampTypeEnum::Value Ifc4::IfcRampType::PredefinedType() const { return ::Ifc4::IfcRampTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcRampType::setPredefinedType(const ::Ifc4::IfcRampTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcRampTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRampType::Class() { return *((IfcParse::entity*)IFC4_types[770]); }
|
|
void Ifc4::IfcRampType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcRampTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcRampTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcRationalBSplineCurveWithKnots
|
|
std::vector< double > /*[2:?]*/ Ifc4::IfcRationalBSplineCurveWithKnots::WeightsData() const { std::vector< double > /*[2:?]*/ v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcRationalBSplineCurveWithKnots::setWeightsData(const std::vector< double > /*[2:?]*/& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRationalBSplineCurveWithKnots::Class() { return *((IfcParse::entity*)IFC4_types[773]); }
|
|
void Ifc4::IfcRationalBSplineCurveWithKnots::initialize(int v1_Degree, std::vector< ::Ifc4::IfcCartesianPoint > v2_ControlPointsList, ::Ifc4::IfcBSplineCurveForm::Value v3_CurveForm, boost::logic::tribool v4_ClosedCurve, boost::logic::tribool v5_SelfIntersect, std::vector< int > /*[2:?]*/ v6_KnotMultiplicities, std::vector< double > /*[2:?]*/ v7_Knots, ::Ifc4::IfcKnotType::Value v8_KnotSpec, std::vector< double > /*[2:?]*/ v9_WeightsData) { set_attribute_value(0, (v1_Degree));set_attribute_value(1, cast_vector<express::Base>(v2_ControlPointsList));set_attribute_value(2, (EnumerationReference(&::Ifc4::IfcBSplineCurveForm::Class(),(size_t)v3_CurveForm)));set_attribute_value(3, (v4_ClosedCurve));set_attribute_value(4, (v5_SelfIntersect));set_attribute_value(5, (v6_KnotMultiplicities));set_attribute_value(6, (v7_Knots));set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcKnotType::Class(),(size_t)v8_KnotSpec)));set_attribute_value(8, (v9_WeightsData)); }
|
|
|
|
// Function implementations for IfcRationalBSplineSurfaceWithKnots
|
|
std::vector< std::vector< double > > Ifc4::IfcRationalBSplineSurfaceWithKnots::WeightsData() const { std::vector< std::vector< double > > v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcRationalBSplineSurfaceWithKnots::setWeightsData(const std::vector< std::vector< double > >& v) { set_attribute_value(12, v);if constexpr (false)unset_attribute_value(12); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRationalBSplineSurfaceWithKnots::Class() { return *((IfcParse::entity*)IFC4_types[774]); }
|
|
void Ifc4::IfcRationalBSplineSurfaceWithKnots::initialize(int v1_UDegree, int v2_VDegree, std::vector< std::vector< ::Ifc4::IfcCartesianPoint > > v3_ControlPointsList, ::Ifc4::IfcBSplineSurfaceForm::Value v4_SurfaceForm, boost::logic::tribool v5_UClosed, boost::logic::tribool v6_VClosed, boost::logic::tribool v7_SelfIntersect, std::vector< int > /*[2:?]*/ v8_UMultiplicities, std::vector< int > /*[2:?]*/ v9_VMultiplicities, std::vector< double > /*[2:?]*/ v10_UKnots, std::vector< double > /*[2:?]*/ v11_VKnots, ::Ifc4::IfcKnotType::Value v12_KnotSpec, std::vector< std::vector< double > > v13_WeightsData) { set_attribute_value(0, (v1_UDegree));set_attribute_value(1, (v2_VDegree));set_attribute_value(2, cast_vector<express::Base>(v3_ControlPointsList));set_attribute_value(3, (EnumerationReference(&::Ifc4::IfcBSplineSurfaceForm::Class(),(size_t)v4_SurfaceForm)));set_attribute_value(4, (v5_UClosed));set_attribute_value(5, (v6_VClosed));set_attribute_value(6, (v7_SelfIntersect));set_attribute_value(7, (v8_UMultiplicities));set_attribute_value(8, (v9_VMultiplicities));set_attribute_value(9, (v10_UKnots));set_attribute_value(10, (v11_VKnots));set_attribute_value(11, (EnumerationReference(&::Ifc4::IfcKnotType::Class(),(size_t)v12_KnotSpec)));set_attribute_value(12, (v13_WeightsData)); }
|
|
|
|
// Function implementations for IfcRectangleHollowProfileDef
|
|
double Ifc4::IfcRectangleHollowProfileDef::WallThickness() const { double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcRectangleHollowProfileDef::setWallThickness(const double& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
std::optional< double > Ifc4::IfcRectangleHollowProfileDef::InnerFilletRadius() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcRectangleHollowProfileDef::setInnerFilletRadius(const std::optional< double >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
std::optional< double > Ifc4::IfcRectangleHollowProfileDef::OuterFilletRadius() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcRectangleHollowProfileDef::setOuterFilletRadius(const std::optional< double >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRectangleHollowProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[776]); }
|
|
void Ifc4::IfcRectangleHollowProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcAxis2Placement2D v3_Position, double v4_XDim, double v5_YDim, double v6_WallThickness, std::optional< double > v7_InnerFilletRadius, std::optional< double > v8_OuterFilletRadius) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Position));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)); } }
|
|
|
|
// Function implementations for IfcRectangleProfileDef
|
|
double Ifc4::IfcRectangleProfileDef::XDim() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcRectangleProfileDef::setXDim(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
double Ifc4::IfcRectangleProfileDef::YDim() const { double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcRectangleProfileDef::setYDim(const double& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRectangleProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[777]); }
|
|
void Ifc4::IfcRectangleProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcAxis2Placement2D v3_Position, double v4_XDim, double v5_YDim) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Position));set_attribute_value(3, (v4_XDim));set_attribute_value(4, (v5_YDim)); }
|
|
|
|
// Function implementations for IfcRectangularPyramid
|
|
double Ifc4::IfcRectangularPyramid::XLength() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcRectangularPyramid::setXLength(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
double Ifc4::IfcRectangularPyramid::YLength() const { double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcRectangularPyramid::setYLength(const double& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
double Ifc4::IfcRectangularPyramid::Height() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcRectangularPyramid::setHeight(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRectangularPyramid::Class() { return *((IfcParse::entity*)IFC4_types[778]); }
|
|
void Ifc4::IfcRectangularPyramid::initialize(::Ifc4::IfcAxis2Placement3D v1_Position, double v2_XLength, double v3_YLength, double v4_Height) { set_attribute_value(0, (v1_Position));set_attribute_value(1, (v2_XLength));set_attribute_value(2, (v3_YLength));set_attribute_value(3, (v4_Height)); }
|
|
|
|
// Function implementations for IfcRectangularTrimmedSurface
|
|
::Ifc4::IfcSurface Ifc4::IfcRectangularTrimmedSurface::BasisSurface() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcSurface>(); }
|
|
void Ifc4::IfcRectangularTrimmedSurface::setBasisSurface(const ::Ifc4::IfcSurface& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
double Ifc4::IfcRectangularTrimmedSurface::U1() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcRectangularTrimmedSurface::setU1(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
double Ifc4::IfcRectangularTrimmedSurface::V1() const { double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcRectangularTrimmedSurface::setV1(const double& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
double Ifc4::IfcRectangularTrimmedSurface::U2() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcRectangularTrimmedSurface::setU2(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
double Ifc4::IfcRectangularTrimmedSurface::V2() const { double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcRectangularTrimmedSurface::setV2(const double& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
bool Ifc4::IfcRectangularTrimmedSurface::Usense() const { bool v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcRectangularTrimmedSurface::setUsense(const bool& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
bool Ifc4::IfcRectangularTrimmedSurface::Vsense() const { bool v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcRectangularTrimmedSurface::setVsense(const bool& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRectangularTrimmedSurface::Class() { return *((IfcParse::entity*)IFC4_types[779]); }
|
|
void Ifc4::IfcRectangularTrimmedSurface::initialize(::Ifc4::IfcSurface v1_BasisSurface, double v2_U1, double v3_V1, double v4_U2, double v5_V2, bool v6_Usense, bool v7_Vsense) { set_attribute_value(0, (v1_BasisSurface));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)); }
|
|
|
|
// Function implementations for IfcRecurrencePattern
|
|
::Ifc4::IfcRecurrenceTypeEnum::Value Ifc4::IfcRecurrencePattern::RecurrenceType() const { return ::Ifc4::IfcRecurrenceTypeEnum::FromString(get_attribute_value(0)); }
|
|
void Ifc4::IfcRecurrencePattern::setRecurrenceType(const ::Ifc4::IfcRecurrenceTypeEnum::Value& v) { set_attribute_value(0, EnumerationReference(&::Ifc4::IfcRecurrenceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< std::vector< int > /*[1:?]*/ > Ifc4::IfcRecurrencePattern::DayComponent() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::vector< int > /*[1:?]*/ v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcRecurrencePattern::setDayComponent(const std::optional< std::vector< int > /*[1:?]*/ >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< std::vector< int > /*[1:?]*/ > Ifc4::IfcRecurrencePattern::WeekdayComponent() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::vector< int > /*[1:?]*/ v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcRecurrencePattern::setWeekdayComponent(const std::optional< std::vector< int > /*[1:?]*/ >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< std::vector< int > /*[1:?]*/ > Ifc4::IfcRecurrencePattern::MonthComponent() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::vector< int > /*[1:?]*/ v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcRecurrencePattern::setMonthComponent(const std::optional< std::vector< int > /*[1:?]*/ >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< int > Ifc4::IfcRecurrencePattern::Position() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } int v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcRecurrencePattern::setPosition(const std::optional< int >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< int > Ifc4::IfcRecurrencePattern::Interval() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } int v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcRecurrencePattern::setInterval(const std::optional< int >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< int > Ifc4::IfcRecurrencePattern::Occurrences() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } int v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcRecurrencePattern::setOccurrences(const std::optional< int >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
std::optional< std::vector< ::Ifc4::IfcTimePeriod > > Ifc4::IfcRecurrencePattern::TimePeriods() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(7); return cast_vector<::Ifc4::IfcTimePeriod>(es); }
|
|
void Ifc4::IfcRecurrencePattern::setTimePeriods(const std::optional< std::vector< ::Ifc4::IfcTimePeriod > >& v) { if (v) {set_attribute_value(7, cast_vector<express::Base>(*v));} else {unset_attribute_value(7);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRecurrencePattern::Class() { return *((IfcParse::entity*)IFC4_types[780]); }
|
|
void Ifc4::IfcRecurrencePattern::initialize(::Ifc4::IfcRecurrenceTypeEnum::Value v1_RecurrenceType, std::optional< std::vector< int > /*[1:?]*/ > v2_DayComponent, std::optional< std::vector< int > /*[1:?]*/ > v3_WeekdayComponent, std::optional< std::vector< int > /*[1:?]*/ > v4_MonthComponent, std::optional< int > v5_Position, std::optional< int > v6_Interval, std::optional< int > v7_Occurrences, std::optional< std::vector< ::Ifc4::IfcTimePeriod > > v8_TimePeriods) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcRecurrenceTypeEnum::Class(),(size_t)v1_RecurrenceType))); if (v2_DayComponent) {set_attribute_value(1, (*v2_DayComponent)); } if (v3_WeekdayComponent) {set_attribute_value(2, (*v3_WeekdayComponent)); } if (v4_MonthComponent) {set_attribute_value(3, (*v4_MonthComponent)); } if (v5_Position) {set_attribute_value(4, (*v5_Position)); } if (v6_Interval) {set_attribute_value(5, (*v6_Interval)); } if (v7_Occurrences) {set_attribute_value(6, (*v7_Occurrences)); } if (v8_TimePeriods) {set_attribute_value(7, cast_vector<express::Base>(*v8_TimePeriods)); } }
|
|
|
|
// Function implementations for IfcReference
|
|
std::optional< std::string > Ifc4::IfcReference::TypeIdentifier() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcReference::setTypeIdentifier(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< std::string > Ifc4::IfcReference::AttributeIdentifier() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcReference::setAttributeIdentifier(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< std::string > Ifc4::IfcReference::InstanceName() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcReference::setInstanceName(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< std::vector< int > /*[1:?]*/ > Ifc4::IfcReference::ListPositions() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::vector< int > /*[1:?]*/ v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcReference::setListPositions(const std::optional< std::vector< int > /*[1:?]*/ >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
::Ifc4::IfcReference Ifc4::IfcReference::InnerReference() const { if(get_attribute_value(4).isNull()) { return ::Ifc4::IfcReference{}; } return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcReference>(); }
|
|
void Ifc4::IfcReference::setInnerReference(const ::Ifc4::IfcReference& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcReference::Class() { return *((IfcParse::entity*)IFC4_types[782]); }
|
|
void Ifc4::IfcReference::initialize(std::optional< std::string > v1_TypeIdentifier, std::optional< std::string > v2_AttributeIdentifier, std::optional< std::string > v3_InstanceName, std::optional< std::vector< int > /*[1:?]*/ > v4_ListPositions, ::Ifc4::IfcReference v5_InnerReference) { if (v1_TypeIdentifier) {set_attribute_value(0, (*v1_TypeIdentifier)); } if (v2_AttributeIdentifier) {set_attribute_value(1, (*v2_AttributeIdentifier)); } if (v3_InstanceName) {set_attribute_value(2, (*v3_InstanceName)); } if (v4_ListPositions) {set_attribute_value(3, (*v4_ListPositions)); }set_attribute_value(4, (v5_InnerReference)); }
|
|
|
|
// Function implementations for IfcRegularTimeSeries
|
|
double Ifc4::IfcRegularTimeSeries::TimeStep() const { double v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcRegularTimeSeries::setTimeStep(const double& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
std::vector< ::Ifc4::IfcTimeSeriesValue > Ifc4::IfcRegularTimeSeries::Values() const { std::vector<express::Base> es = get_attribute_value(9); return cast_vector<::Ifc4::IfcTimeSeriesValue>(es); }
|
|
void Ifc4::IfcRegularTimeSeries::setValues(const std::vector< ::Ifc4::IfcTimeSeriesValue >& v) { set_attribute_value(9, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRegularTimeSeries::Class() { return *((IfcParse::entity*)IFC4_types[784]); }
|
|
void Ifc4::IfcRegularTimeSeries::initialize(std::string v1_Name, std::optional< std::string > v2_Description, std::string v3_StartTime, std::string v4_EndTime, ::Ifc4::IfcTimeSeriesDataTypeEnum::Value v5_TimeSeriesDataType, ::Ifc4::IfcDataOriginEnum::Value v6_DataOrigin, std::optional< std::string > v7_UserDefinedDataOrigin, ::Ifc4::IfcUnit v8_Unit, double v9_TimeStep, std::vector< ::Ifc4::IfcTimeSeriesValue > v10_Values) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_StartTime));set_attribute_value(3, (v4_EndTime));set_attribute_value(4, (EnumerationReference(&::Ifc4::IfcTimeSeriesDataTypeEnum::Class(),(size_t)v5_TimeSeriesDataType)));set_attribute_value(5, (EnumerationReference(&::Ifc4::IfcDataOriginEnum::Class(),(size_t)v6_DataOrigin))); if (v7_UserDefinedDataOrigin) {set_attribute_value(6, (*v7_UserDefinedDataOrigin)); }set_attribute_value(7, (v8_Unit));set_attribute_value(8, (v9_TimeStep));set_attribute_value(9, cast_vector<express::Base>(v10_Values)); }
|
|
|
|
// Function implementations for IfcReinforcementBarProperties
|
|
double Ifc4::IfcReinforcementBarProperties::TotalCrossSectionArea() const { double v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcReinforcementBarProperties::setTotalCrossSectionArea(const double& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::string Ifc4::IfcReinforcementBarProperties::SteelGrade() const { std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcReinforcementBarProperties::setSteelGrade(const std::string& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
std::optional< ::Ifc4::IfcReinforcingBarSurfaceEnum::Value > Ifc4::IfcReinforcementBarProperties::BarSurface() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } return ::Ifc4::IfcReinforcingBarSurfaceEnum::FromString(get_attribute_value(2)); }
|
|
void Ifc4::IfcReinforcementBarProperties::setBarSurface(const std::optional< ::Ifc4::IfcReinforcingBarSurfaceEnum::Value >& v) { if (v) {set_attribute_value(2, EnumerationReference(&::Ifc4::IfcReinforcingBarSurfaceEnum::Class(), (size_t) *v));} else {unset_attribute_value(2);} }
|
|
std::optional< double > Ifc4::IfcReinforcementBarProperties::EffectiveDepth() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcReinforcementBarProperties::setEffectiveDepth(const std::optional< double >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< double > Ifc4::IfcReinforcementBarProperties::NominalBarDiameter() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcReinforcementBarProperties::setNominalBarDiameter(const std::optional< double >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< double > Ifc4::IfcReinforcementBarProperties::BarCount() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcReinforcementBarProperties::setBarCount(const std::optional< double >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcReinforcementBarProperties::Class() { return *((IfcParse::entity*)IFC4_types[785]); }
|
|
void Ifc4::IfcReinforcementBarProperties::initialize(double v1_TotalCrossSectionArea, std::string v2_SteelGrade, std::optional< ::Ifc4::IfcReinforcingBarSurfaceEnum::Value > v3_BarSurface, std::optional< double > v4_EffectiveDepth, std::optional< double > v5_NominalBarDiameter, std::optional< double > v6_BarCount) { set_attribute_value(0, (v1_TotalCrossSectionArea));set_attribute_value(1, (v2_SteelGrade)); if (v3_BarSurface) {set_attribute_value(2, (EnumerationReference(&::Ifc4::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)); } }
|
|
|
|
// Function implementations for IfcReinforcementDefinitionProperties
|
|
std::optional< std::string > Ifc4::IfcReinforcementDefinitionProperties::DefinitionType() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcReinforcementDefinitionProperties::setDefinitionType(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::vector< ::Ifc4::IfcSectionReinforcementProperties > Ifc4::IfcReinforcementDefinitionProperties::ReinforcementSectionDefinitions() const { std::vector<express::Base> es = get_attribute_value(5); return cast_vector<::Ifc4::IfcSectionReinforcementProperties>(es); }
|
|
void Ifc4::IfcReinforcementDefinitionProperties::setReinforcementSectionDefinitions(const std::vector< ::Ifc4::IfcSectionReinforcementProperties >& v) { set_attribute_value(5, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcReinforcementDefinitionProperties::Class() { return *((IfcParse::entity*)IFC4_types[786]); }
|
|
void Ifc4::IfcReinforcementDefinitionProperties::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_DefinitionType, std::vector< ::Ifc4::IfcSectionReinforcementProperties > v6_ReinforcementSectionDefinitions) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(v6_ReinforcementSectionDefinitions)); }
|
|
|
|
// Function implementations for IfcReinforcingBar
|
|
std::optional< double > Ifc4::IfcReinforcingBar::NominalDiameter() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } double v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcReinforcingBar::setNominalDiameter(const std::optional< double >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
std::optional< double > Ifc4::IfcReinforcingBar::CrossSectionArea() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } double v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcReinforcingBar::setCrossSectionArea(const std::optional< double >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::optional< double > Ifc4::IfcReinforcingBar::BarLength() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } double v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcReinforcingBar::setBarLength(const std::optional< double >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
std::optional< ::Ifc4::IfcReinforcingBarTypeEnum::Value > Ifc4::IfcReinforcingBar::PredefinedType() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } return ::Ifc4::IfcReinforcingBarTypeEnum::FromString(get_attribute_value(12)); }
|
|
void Ifc4::IfcReinforcingBar::setPredefinedType(const std::optional< ::Ifc4::IfcReinforcingBarTypeEnum::Value >& v) { if (v) {set_attribute_value(12, EnumerationReference(&::Ifc4::IfcReinforcingBarTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(12);} }
|
|
std::optional< ::Ifc4::IfcReinforcingBarSurfaceEnum::Value > Ifc4::IfcReinforcingBar::BarSurface() const { if(get_attribute_value(13).isNull()) { return std::nullopt; } return ::Ifc4::IfcReinforcingBarSurfaceEnum::FromString(get_attribute_value(13)); }
|
|
void Ifc4::IfcReinforcingBar::setBarSurface(const std::optional< ::Ifc4::IfcReinforcingBarSurfaceEnum::Value >& v) { if (v) {set_attribute_value(13, EnumerationReference(&::Ifc4::IfcReinforcingBarSurfaceEnum::Class(), (size_t) *v));} else {unset_attribute_value(13);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcReinforcingBar::Class() { return *((IfcParse::entity*)IFC4_types[787]); }
|
|
void Ifc4::IfcReinforcingBar::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< std::string > v9_SteelGrade, std::optional< double > v10_NominalDiameter, std::optional< double > v11_CrossSectionArea, std::optional< double > v12_BarLength, std::optional< ::Ifc4::IfcReinforcingBarTypeEnum::Value > v13_PredefinedType, std::optional< ::Ifc4::IfcReinforcingBarSurfaceEnum::Value > v14_BarSurface) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_SteelGrade) {set_attribute_value(8, (*v9_SteelGrade)); } if (v10_NominalDiameter) {set_attribute_value(9, (*v10_NominalDiameter)); } if (v11_CrossSectionArea) {set_attribute_value(10, (*v11_CrossSectionArea)); } if (v12_BarLength) {set_attribute_value(11, (*v12_BarLength)); } if (v13_PredefinedType) {set_attribute_value(12, (EnumerationReference(&::Ifc4::IfcReinforcingBarTypeEnum::Class(),(size_t)*v13_PredefinedType))); } if (v14_BarSurface) {set_attribute_value(13, (EnumerationReference(&::Ifc4::IfcReinforcingBarSurfaceEnum::Class(),(size_t)*v14_BarSurface))); } }
|
|
|
|
// Function implementations for IfcReinforcingBarType
|
|
::Ifc4::IfcReinforcingBarTypeEnum::Value Ifc4::IfcReinforcingBarType::PredefinedType() const { return ::Ifc4::IfcReinforcingBarTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcReinforcingBarType::setPredefinedType(const ::Ifc4::IfcReinforcingBarTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcReinforcingBarTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
std::optional< double > Ifc4::IfcReinforcingBarType::NominalDiameter() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } double v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcReinforcingBarType::setNominalDiameter(const std::optional< double >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::optional< double > Ifc4::IfcReinforcingBarType::CrossSectionArea() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } double v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcReinforcingBarType::setCrossSectionArea(const std::optional< double >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
std::optional< double > Ifc4::IfcReinforcingBarType::BarLength() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } double v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcReinforcingBarType::setBarLength(const std::optional< double >& v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
|
|
std::optional< ::Ifc4::IfcReinforcingBarSurfaceEnum::Value > Ifc4::IfcReinforcingBarType::BarSurface() const { if(get_attribute_value(13).isNull()) { return std::nullopt; } return ::Ifc4::IfcReinforcingBarSurfaceEnum::FromString(get_attribute_value(13)); }
|
|
void Ifc4::IfcReinforcingBarType::setBarSurface(const std::optional< ::Ifc4::IfcReinforcingBarSurfaceEnum::Value >& v) { if (v) {set_attribute_value(13, EnumerationReference(&::Ifc4::IfcReinforcingBarSurfaceEnum::Class(), (size_t) *v));} else {unset_attribute_value(13);} }
|
|
std::optional< std::string > Ifc4::IfcReinforcingBarType::BendingShapeCode() const { if(get_attribute_value(14).isNull()) { return std::nullopt; } std::string v = get_attribute_value(14); return v; }
|
|
void Ifc4::IfcReinforcingBarType::setBendingShapeCode(const std::optional< std::string >& v) { if (v) {set_attribute_value(14, *v);} else {unset_attribute_value(14);} }
|
|
std::optional< std::vector< ::Ifc4::IfcBendingParameterSelect > > Ifc4::IfcReinforcingBarType::BendingParameters() const { if(get_attribute_value(15).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(15); return cast_vector<::Ifc4::IfcBendingParameterSelect>(es); }
|
|
void Ifc4::IfcReinforcingBarType::setBendingParameters(const std::optional< std::vector< ::Ifc4::IfcBendingParameterSelect > >& v) { if (v) {set_attribute_value(15, cast_vector<express::Base>(*v));} else {unset_attribute_value(15);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcReinforcingBarType::Class() { return *((IfcParse::entity*)IFC4_types[790]); }
|
|
void Ifc4::IfcReinforcingBarType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcReinforcingBarTypeEnum::Value v10_PredefinedType, std::optional< double > v11_NominalDiameter, std::optional< double > v12_CrossSectionArea, std::optional< double > v13_BarLength, std::optional< ::Ifc4::IfcReinforcingBarSurfaceEnum::Value > v14_BarSurface, std::optional< std::string > v15_BendingShapeCode, std::optional< std::vector< ::Ifc4::IfcBendingParameterSelect > > v16_BendingParameters) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcReinforcingBarTypeEnum::Class(),(size_t)v10_PredefinedType))); if (v11_NominalDiameter) {set_attribute_value(10, (*v11_NominalDiameter)); } if (v12_CrossSectionArea) {set_attribute_value(11, (*v12_CrossSectionArea)); } if (v13_BarLength) {set_attribute_value(12, (*v13_BarLength)); } if (v14_BarSurface) {set_attribute_value(13, (EnumerationReference(&::Ifc4::IfcReinforcingBarSurfaceEnum::Class(),(size_t)*v14_BarSurface))); } if (v15_BendingShapeCode) {set_attribute_value(14, (*v15_BendingShapeCode)); } if (v16_BendingParameters) {set_attribute_value(15, cast_vector<express::Base>(*v16_BendingParameters)); } }
|
|
|
|
// Function implementations for IfcReinforcingElement
|
|
std::optional< std::string > Ifc4::IfcReinforcingElement::SteelGrade() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcReinforcingElement::setSteelGrade(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcReinforcingElement::Class() { return *((IfcParse::entity*)IFC4_types[792]); }
|
|
void Ifc4::IfcReinforcingElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< std::string > v9_SteelGrade) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_SteelGrade) {set_attribute_value(8, (*v9_SteelGrade)); } }
|
|
|
|
// Function implementations for IfcReinforcingElementType
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcReinforcingElementType::Class() { return *((IfcParse::entity*)IFC4_types[793]); }
|
|
void Ifc4::IfcReinforcingElementType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcReinforcingMesh
|
|
std::optional< double > Ifc4::IfcReinforcingMesh::MeshLength() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } double v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcReinforcingMesh::setMeshLength(const std::optional< double >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
std::optional< double > Ifc4::IfcReinforcingMesh::MeshWidth() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } double v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcReinforcingMesh::setMeshWidth(const std::optional< double >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::optional< double > Ifc4::IfcReinforcingMesh::LongitudinalBarNominalDiameter() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } double v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcReinforcingMesh::setLongitudinalBarNominalDiameter(const std::optional< double >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
std::optional< double > Ifc4::IfcReinforcingMesh::TransverseBarNominalDiameter() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } double v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcReinforcingMesh::setTransverseBarNominalDiameter(const std::optional< double >& v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
|
|
std::optional< double > Ifc4::IfcReinforcingMesh::LongitudinalBarCrossSectionArea() const { if(get_attribute_value(13).isNull()) { return std::nullopt; } double v = get_attribute_value(13); return v; }
|
|
void Ifc4::IfcReinforcingMesh::setLongitudinalBarCrossSectionArea(const std::optional< double >& v) { if (v) {set_attribute_value(13, *v);} else {unset_attribute_value(13);} }
|
|
std::optional< double > Ifc4::IfcReinforcingMesh::TransverseBarCrossSectionArea() const { if(get_attribute_value(14).isNull()) { return std::nullopt; } double v = get_attribute_value(14); return v; }
|
|
void Ifc4::IfcReinforcingMesh::setTransverseBarCrossSectionArea(const std::optional< double >& v) { if (v) {set_attribute_value(14, *v);} else {unset_attribute_value(14);} }
|
|
std::optional< double > Ifc4::IfcReinforcingMesh::LongitudinalBarSpacing() const { if(get_attribute_value(15).isNull()) { return std::nullopt; } double v = get_attribute_value(15); return v; }
|
|
void Ifc4::IfcReinforcingMesh::setLongitudinalBarSpacing(const std::optional< double >& v) { if (v) {set_attribute_value(15, *v);} else {unset_attribute_value(15);} }
|
|
std::optional< double > Ifc4::IfcReinforcingMesh::TransverseBarSpacing() const { if(get_attribute_value(16).isNull()) { return std::nullopt; } double v = get_attribute_value(16); return v; }
|
|
void Ifc4::IfcReinforcingMesh::setTransverseBarSpacing(const std::optional< double >& v) { if (v) {set_attribute_value(16, *v);} else {unset_attribute_value(16);} }
|
|
std::optional< ::Ifc4::IfcReinforcingMeshTypeEnum::Value > Ifc4::IfcReinforcingMesh::PredefinedType() const { if(get_attribute_value(17).isNull()) { return std::nullopt; } return ::Ifc4::IfcReinforcingMeshTypeEnum::FromString(get_attribute_value(17)); }
|
|
void Ifc4::IfcReinforcingMesh::setPredefinedType(const std::optional< ::Ifc4::IfcReinforcingMeshTypeEnum::Value >& v) { if (v) {set_attribute_value(17, EnumerationReference(&::Ifc4::IfcReinforcingMeshTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(17);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcReinforcingMesh::Class() { return *((IfcParse::entity*)IFC4_types[794]); }
|
|
void Ifc4::IfcReinforcingMesh::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< std::string > v9_SteelGrade, std::optional< double > v10_MeshLength, std::optional< double > v11_MeshWidth, std::optional< double > v12_LongitudinalBarNominalDiameter, std::optional< double > v13_TransverseBarNominalDiameter, std::optional< double > v14_LongitudinalBarCrossSectionArea, std::optional< double > v15_TransverseBarCrossSectionArea, std::optional< double > v16_LongitudinalBarSpacing, std::optional< double > v17_TransverseBarSpacing, std::optional< ::Ifc4::IfcReinforcingMeshTypeEnum::Value > v18_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); 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)); } if (v12_LongitudinalBarNominalDiameter) {set_attribute_value(11, (*v12_LongitudinalBarNominalDiameter)); } if (v13_TransverseBarNominalDiameter) {set_attribute_value(12, (*v13_TransverseBarNominalDiameter)); } if (v14_LongitudinalBarCrossSectionArea) {set_attribute_value(13, (*v14_LongitudinalBarCrossSectionArea)); } if (v15_TransverseBarCrossSectionArea) {set_attribute_value(14, (*v15_TransverseBarCrossSectionArea)); } if (v16_LongitudinalBarSpacing) {set_attribute_value(15, (*v16_LongitudinalBarSpacing)); } if (v17_TransverseBarSpacing) {set_attribute_value(16, (*v17_TransverseBarSpacing)); } if (v18_PredefinedType) {set_attribute_value(17, (EnumerationReference(&::Ifc4::IfcReinforcingMeshTypeEnum::Class(),(size_t)*v18_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcReinforcingMeshType
|
|
::Ifc4::IfcReinforcingMeshTypeEnum::Value Ifc4::IfcReinforcingMeshType::PredefinedType() const { return ::Ifc4::IfcReinforcingMeshTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcReinforcingMeshType::setPredefinedType(const ::Ifc4::IfcReinforcingMeshTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcReinforcingMeshTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
std::optional< double > Ifc4::IfcReinforcingMeshType::MeshLength() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } double v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcReinforcingMeshType::setMeshLength(const std::optional< double >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::optional< double > Ifc4::IfcReinforcingMeshType::MeshWidth() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } double v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcReinforcingMeshType::setMeshWidth(const std::optional< double >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
std::optional< double > Ifc4::IfcReinforcingMeshType::LongitudinalBarNominalDiameter() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } double v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcReinforcingMeshType::setLongitudinalBarNominalDiameter(const std::optional< double >& v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
|
|
std::optional< double > Ifc4::IfcReinforcingMeshType::TransverseBarNominalDiameter() const { if(get_attribute_value(13).isNull()) { return std::nullopt; } double v = get_attribute_value(13); return v; }
|
|
void Ifc4::IfcReinforcingMeshType::setTransverseBarNominalDiameter(const std::optional< double >& v) { if (v) {set_attribute_value(13, *v);} else {unset_attribute_value(13);} }
|
|
std::optional< double > Ifc4::IfcReinforcingMeshType::LongitudinalBarCrossSectionArea() const { if(get_attribute_value(14).isNull()) { return std::nullopt; } double v = get_attribute_value(14); return v; }
|
|
void Ifc4::IfcReinforcingMeshType::setLongitudinalBarCrossSectionArea(const std::optional< double >& v) { if (v) {set_attribute_value(14, *v);} else {unset_attribute_value(14);} }
|
|
std::optional< double > Ifc4::IfcReinforcingMeshType::TransverseBarCrossSectionArea() const { if(get_attribute_value(15).isNull()) { return std::nullopt; } double v = get_attribute_value(15); return v; }
|
|
void Ifc4::IfcReinforcingMeshType::setTransverseBarCrossSectionArea(const std::optional< double >& v) { if (v) {set_attribute_value(15, *v);} else {unset_attribute_value(15);} }
|
|
std::optional< double > Ifc4::IfcReinforcingMeshType::LongitudinalBarSpacing() const { if(get_attribute_value(16).isNull()) { return std::nullopt; } double v = get_attribute_value(16); return v; }
|
|
void Ifc4::IfcReinforcingMeshType::setLongitudinalBarSpacing(const std::optional< double >& v) { if (v) {set_attribute_value(16, *v);} else {unset_attribute_value(16);} }
|
|
std::optional< double > Ifc4::IfcReinforcingMeshType::TransverseBarSpacing() const { if(get_attribute_value(17).isNull()) { return std::nullopt; } double v = get_attribute_value(17); return v; }
|
|
void Ifc4::IfcReinforcingMeshType::setTransverseBarSpacing(const std::optional< double >& v) { if (v) {set_attribute_value(17, *v);} else {unset_attribute_value(17);} }
|
|
std::optional< std::string > Ifc4::IfcReinforcingMeshType::BendingShapeCode() const { if(get_attribute_value(18).isNull()) { return std::nullopt; } std::string v = get_attribute_value(18); return v; }
|
|
void Ifc4::IfcReinforcingMeshType::setBendingShapeCode(const std::optional< std::string >& v) { if (v) {set_attribute_value(18, *v);} else {unset_attribute_value(18);} }
|
|
std::optional< std::vector< ::Ifc4::IfcBendingParameterSelect > > Ifc4::IfcReinforcingMeshType::BendingParameters() const { if(get_attribute_value(19).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(19); return cast_vector<::Ifc4::IfcBendingParameterSelect>(es); }
|
|
void Ifc4::IfcReinforcingMeshType::setBendingParameters(const std::optional< std::vector< ::Ifc4::IfcBendingParameterSelect > >& v) { if (v) {set_attribute_value(19, cast_vector<express::Base>(*v));} else {unset_attribute_value(19);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcReinforcingMeshType::Class() { return *((IfcParse::entity*)IFC4_types[795]); }
|
|
void Ifc4::IfcReinforcingMeshType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcReinforcingMeshTypeEnum::Value v10_PredefinedType, std::optional< double > v11_MeshLength, std::optional< double > v12_MeshWidth, std::optional< double > v13_LongitudinalBarNominalDiameter, std::optional< double > v14_TransverseBarNominalDiameter, std::optional< double > v15_LongitudinalBarCrossSectionArea, std::optional< double > v16_TransverseBarCrossSectionArea, std::optional< double > v17_LongitudinalBarSpacing, std::optional< double > v18_TransverseBarSpacing, std::optional< std::string > v19_BendingShapeCode, std::optional< std::vector< ::Ifc4::IfcBendingParameterSelect > > v20_BendingParameters) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcReinforcingMeshTypeEnum::Class(),(size_t)v10_PredefinedType))); if (v11_MeshLength) {set_attribute_value(10, (*v11_MeshLength)); } if (v12_MeshWidth) {set_attribute_value(11, (*v12_MeshWidth)); } if (v13_LongitudinalBarNominalDiameter) {set_attribute_value(12, (*v13_LongitudinalBarNominalDiameter)); } if (v14_TransverseBarNominalDiameter) {set_attribute_value(13, (*v14_TransverseBarNominalDiameter)); } if (v15_LongitudinalBarCrossSectionArea) {set_attribute_value(14, (*v15_LongitudinalBarCrossSectionArea)); } if (v16_TransverseBarCrossSectionArea) {set_attribute_value(15, (*v16_TransverseBarCrossSectionArea)); } if (v17_LongitudinalBarSpacing) {set_attribute_value(16, (*v17_LongitudinalBarSpacing)); } if (v18_TransverseBarSpacing) {set_attribute_value(17, (*v18_TransverseBarSpacing)); } if (v19_BendingShapeCode) {set_attribute_value(18, (*v19_BendingShapeCode)); } if (v20_BendingParameters) {set_attribute_value(19, cast_vector<express::Base>(*v20_BendingParameters)); } }
|
|
|
|
// Function implementations for IfcRelAggregates
|
|
::Ifc4::IfcObjectDefinition Ifc4::IfcRelAggregates::RelatingObject() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcObjectDefinition>(); }
|
|
void Ifc4::IfcRelAggregates::setRelatingObject(const ::Ifc4::IfcObjectDefinition& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
std::vector< ::Ifc4::IfcObjectDefinition > Ifc4::IfcRelAggregates::RelatedObjects() const { std::vector<express::Base> es = get_attribute_value(5); return cast_vector<::Ifc4::IfcObjectDefinition>(es); }
|
|
void Ifc4::IfcRelAggregates::setRelatedObjects(const std::vector< ::Ifc4::IfcObjectDefinition >& v) { set_attribute_value(5, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelAggregates::Class() { return *((IfcParse::entity*)IFC4_types[797]); }
|
|
void Ifc4::IfcRelAggregates::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcObjectDefinition v5_RelatingObject, std::vector< ::Ifc4::IfcObjectDefinition > v6_RelatedObjects) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingObject));set_attribute_value(5, cast_vector<express::Base>(v6_RelatedObjects)); }
|
|
|
|
// Function implementations for IfcRelAssigns
|
|
std::vector< ::Ifc4::IfcObjectDefinition > Ifc4::IfcRelAssigns::RelatedObjects() const { std::vector<express::Base> es = get_attribute_value(4); return cast_vector<::Ifc4::IfcObjectDefinition>(es); }
|
|
void Ifc4::IfcRelAssigns::setRelatedObjects(const std::vector< ::Ifc4::IfcObjectDefinition >& v) { set_attribute_value(4, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(4); }
|
|
std::optional< ::Ifc4::IfcObjectTypeEnum::Value > Ifc4::IfcRelAssigns::RelatedObjectsType() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } return ::Ifc4::IfcObjectTypeEnum::FromString(get_attribute_value(5)); }
|
|
void Ifc4::IfcRelAssigns::setRelatedObjectsType(const std::optional< ::Ifc4::IfcObjectTypeEnum::Value >& v) { if (v) {set_attribute_value(5, EnumerationReference(&::Ifc4::IfcObjectTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(5);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelAssigns::Class() { return *((IfcParse::entity*)IFC4_types[798]); }
|
|
void Ifc4::IfcRelAssigns::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcObjectDefinition > v5_RelatedObjects, std::optional< ::Ifc4::IfcObjectTypeEnum::Value > v6_RelatedObjectsType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects)); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc4::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); } }
|
|
|
|
// Function implementations for IfcRelAssignsToActor
|
|
::Ifc4::IfcActor Ifc4::IfcRelAssignsToActor::RelatingActor() const { return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcActor>(); }
|
|
void Ifc4::IfcRelAssignsToActor::setRelatingActor(const ::Ifc4::IfcActor& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
::Ifc4::IfcActorRole Ifc4::IfcRelAssignsToActor::ActingRole() const { if(get_attribute_value(7).isNull()) { return ::Ifc4::IfcActorRole{}; } return ((express::Base)(get_attribute_value(7))).as<::Ifc4::IfcActorRole>(); }
|
|
void Ifc4::IfcRelAssignsToActor::setActingRole(const ::Ifc4::IfcActorRole& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelAssignsToActor::Class() { return *((IfcParse::entity*)IFC4_types[799]); }
|
|
void Ifc4::IfcRelAssignsToActor::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcObjectDefinition > v5_RelatedObjects, std::optional< ::Ifc4::IfcObjectTypeEnum::Value > v6_RelatedObjectsType, ::Ifc4::IfcActor v7_RelatingActor, ::Ifc4::IfcActorRole v8_ActingRole) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects)); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc4::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }set_attribute_value(6, (v7_RelatingActor));set_attribute_value(7, (v8_ActingRole)); }
|
|
|
|
// Function implementations for IfcRelAssignsToControl
|
|
::Ifc4::IfcControl Ifc4::IfcRelAssignsToControl::RelatingControl() const { return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcControl>(); }
|
|
void Ifc4::IfcRelAssignsToControl::setRelatingControl(const ::Ifc4::IfcControl& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelAssignsToControl::Class() { return *((IfcParse::entity*)IFC4_types[800]); }
|
|
void Ifc4::IfcRelAssignsToControl::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcObjectDefinition > v5_RelatedObjects, std::optional< ::Ifc4::IfcObjectTypeEnum::Value > v6_RelatedObjectsType, ::Ifc4::IfcControl v7_RelatingControl) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects)); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc4::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }set_attribute_value(6, (v7_RelatingControl)); }
|
|
|
|
// Function implementations for IfcRelAssignsToGroup
|
|
::Ifc4::IfcGroup Ifc4::IfcRelAssignsToGroup::RelatingGroup() const { return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcGroup>(); }
|
|
void Ifc4::IfcRelAssignsToGroup::setRelatingGroup(const ::Ifc4::IfcGroup& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelAssignsToGroup::Class() { return *((IfcParse::entity*)IFC4_types[801]); }
|
|
void Ifc4::IfcRelAssignsToGroup::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcObjectDefinition > v5_RelatedObjects, std::optional< ::Ifc4::IfcObjectTypeEnum::Value > v6_RelatedObjectsType, ::Ifc4::IfcGroup v7_RelatingGroup) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects)); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc4::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }set_attribute_value(6, (v7_RelatingGroup)); }
|
|
|
|
// Function implementations for IfcRelAssignsToGroupByFactor
|
|
double Ifc4::IfcRelAssignsToGroupByFactor::Factor() const { double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcRelAssignsToGroupByFactor::setFactor(const double& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelAssignsToGroupByFactor::Class() { return *((IfcParse::entity*)IFC4_types[802]); }
|
|
void Ifc4::IfcRelAssignsToGroupByFactor::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcObjectDefinition > v5_RelatedObjects, std::optional< ::Ifc4::IfcObjectTypeEnum::Value > v6_RelatedObjectsType, ::Ifc4::IfcGroup v7_RelatingGroup, double v8_Factor) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects)); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc4::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }set_attribute_value(6, (v7_RelatingGroup));set_attribute_value(7, (v8_Factor)); }
|
|
|
|
// Function implementations for IfcRelAssignsToProcess
|
|
::Ifc4::IfcProcessSelect Ifc4::IfcRelAssignsToProcess::RelatingProcess() const { return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcProcessSelect>(); }
|
|
void Ifc4::IfcRelAssignsToProcess::setRelatingProcess(const ::Ifc4::IfcProcessSelect& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
::Ifc4::IfcMeasureWithUnit Ifc4::IfcRelAssignsToProcess::QuantityInProcess() const { if(get_attribute_value(7).isNull()) { return ::Ifc4::IfcMeasureWithUnit{}; } return ((express::Base)(get_attribute_value(7))).as<::Ifc4::IfcMeasureWithUnit>(); }
|
|
void Ifc4::IfcRelAssignsToProcess::setQuantityInProcess(const ::Ifc4::IfcMeasureWithUnit& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelAssignsToProcess::Class() { return *((IfcParse::entity*)IFC4_types[803]); }
|
|
void Ifc4::IfcRelAssignsToProcess::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcObjectDefinition > v5_RelatedObjects, std::optional< ::Ifc4::IfcObjectTypeEnum::Value > v6_RelatedObjectsType, ::Ifc4::IfcProcessSelect v7_RelatingProcess, ::Ifc4::IfcMeasureWithUnit v8_QuantityInProcess) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects)); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc4::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }set_attribute_value(6, (v7_RelatingProcess));set_attribute_value(7, (v8_QuantityInProcess)); }
|
|
|
|
// Function implementations for IfcRelAssignsToProduct
|
|
::Ifc4::IfcProductSelect Ifc4::IfcRelAssignsToProduct::RelatingProduct() const { return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcProductSelect>(); }
|
|
void Ifc4::IfcRelAssignsToProduct::setRelatingProduct(const ::Ifc4::IfcProductSelect& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelAssignsToProduct::Class() { return *((IfcParse::entity*)IFC4_types[804]); }
|
|
void Ifc4::IfcRelAssignsToProduct::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcObjectDefinition > v5_RelatedObjects, std::optional< ::Ifc4::IfcObjectTypeEnum::Value > v6_RelatedObjectsType, ::Ifc4::IfcProductSelect v7_RelatingProduct) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects)); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc4::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }set_attribute_value(6, (v7_RelatingProduct)); }
|
|
|
|
// Function implementations for IfcRelAssignsToResource
|
|
::Ifc4::IfcResourceSelect Ifc4::IfcRelAssignsToResource::RelatingResource() const { return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcResourceSelect>(); }
|
|
void Ifc4::IfcRelAssignsToResource::setRelatingResource(const ::Ifc4::IfcResourceSelect& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelAssignsToResource::Class() { return *((IfcParse::entity*)IFC4_types[805]); }
|
|
void Ifc4::IfcRelAssignsToResource::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcObjectDefinition > v5_RelatedObjects, std::optional< ::Ifc4::IfcObjectTypeEnum::Value > v6_RelatedObjectsType, ::Ifc4::IfcResourceSelect v7_RelatingResource) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects)); if (v6_RelatedObjectsType) {set_attribute_value(5, (EnumerationReference(&::Ifc4::IfcObjectTypeEnum::Class(),(size_t)*v6_RelatedObjectsType))); }set_attribute_value(6, (v7_RelatingResource)); }
|
|
|
|
// Function implementations for IfcRelAssociates
|
|
std::vector< ::Ifc4::IfcDefinitionSelect > Ifc4::IfcRelAssociates::RelatedObjects() const { std::vector<express::Base> es = get_attribute_value(4); return cast_vector<::Ifc4::IfcDefinitionSelect>(es); }
|
|
void Ifc4::IfcRelAssociates::setRelatedObjects(const std::vector< ::Ifc4::IfcDefinitionSelect >& v) { set_attribute_value(4, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelAssociates::Class() { return *((IfcParse::entity*)IFC4_types[806]); }
|
|
void Ifc4::IfcRelAssociates::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcDefinitionSelect > v5_RelatedObjects) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects)); }
|
|
|
|
// Function implementations for IfcRelAssociatesApproval
|
|
::Ifc4::IfcApproval Ifc4::IfcRelAssociatesApproval::RelatingApproval() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcApproval>(); }
|
|
void Ifc4::IfcRelAssociatesApproval::setRelatingApproval(const ::Ifc4::IfcApproval& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelAssociatesApproval::Class() { return *((IfcParse::entity*)IFC4_types[807]); }
|
|
void Ifc4::IfcRelAssociatesApproval::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcDefinitionSelect > v5_RelatedObjects, ::Ifc4::IfcApproval v6_RelatingApproval) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects));set_attribute_value(5, (v6_RelatingApproval)); }
|
|
|
|
// Function implementations for IfcRelAssociatesClassification
|
|
::Ifc4::IfcClassificationSelect Ifc4::IfcRelAssociatesClassification::RelatingClassification() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcClassificationSelect>(); }
|
|
void Ifc4::IfcRelAssociatesClassification::setRelatingClassification(const ::Ifc4::IfcClassificationSelect& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelAssociatesClassification::Class() { return *((IfcParse::entity*)IFC4_types[808]); }
|
|
void Ifc4::IfcRelAssociatesClassification::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcDefinitionSelect > v5_RelatedObjects, ::Ifc4::IfcClassificationSelect v6_RelatingClassification) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects));set_attribute_value(5, (v6_RelatingClassification)); }
|
|
|
|
// Function implementations for IfcRelAssociatesConstraint
|
|
std::optional< std::string > Ifc4::IfcRelAssociatesConstraint::Intent() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcRelAssociatesConstraint::setIntent(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
::Ifc4::IfcConstraint Ifc4::IfcRelAssociatesConstraint::RelatingConstraint() const { return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcConstraint>(); }
|
|
void Ifc4::IfcRelAssociatesConstraint::setRelatingConstraint(const ::Ifc4::IfcConstraint& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelAssociatesConstraint::Class() { return *((IfcParse::entity*)IFC4_types[809]); }
|
|
void Ifc4::IfcRelAssociatesConstraint::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcDefinitionSelect > v5_RelatedObjects, std::optional< std::string > v6_Intent, ::Ifc4::IfcConstraint v7_RelatingConstraint) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects)); if (v6_Intent) {set_attribute_value(5, (*v6_Intent)); }set_attribute_value(6, (v7_RelatingConstraint)); }
|
|
|
|
// Function implementations for IfcRelAssociatesDocument
|
|
::Ifc4::IfcDocumentSelect Ifc4::IfcRelAssociatesDocument::RelatingDocument() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcDocumentSelect>(); }
|
|
void Ifc4::IfcRelAssociatesDocument::setRelatingDocument(const ::Ifc4::IfcDocumentSelect& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelAssociatesDocument::Class() { return *((IfcParse::entity*)IFC4_types[810]); }
|
|
void Ifc4::IfcRelAssociatesDocument::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcDefinitionSelect > v5_RelatedObjects, ::Ifc4::IfcDocumentSelect v6_RelatingDocument) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects));set_attribute_value(5, (v6_RelatingDocument)); }
|
|
|
|
// Function implementations for IfcRelAssociatesLibrary
|
|
::Ifc4::IfcLibrarySelect Ifc4::IfcRelAssociatesLibrary::RelatingLibrary() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcLibrarySelect>(); }
|
|
void Ifc4::IfcRelAssociatesLibrary::setRelatingLibrary(const ::Ifc4::IfcLibrarySelect& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelAssociatesLibrary::Class() { return *((IfcParse::entity*)IFC4_types[811]); }
|
|
void Ifc4::IfcRelAssociatesLibrary::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcDefinitionSelect > v5_RelatedObjects, ::Ifc4::IfcLibrarySelect v6_RelatingLibrary) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects));set_attribute_value(5, (v6_RelatingLibrary)); }
|
|
|
|
// Function implementations for IfcRelAssociatesMaterial
|
|
::Ifc4::IfcMaterialSelect Ifc4::IfcRelAssociatesMaterial::RelatingMaterial() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcMaterialSelect>(); }
|
|
void Ifc4::IfcRelAssociatesMaterial::setRelatingMaterial(const ::Ifc4::IfcMaterialSelect& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelAssociatesMaterial::Class() { return *((IfcParse::entity*)IFC4_types[812]); }
|
|
void Ifc4::IfcRelAssociatesMaterial::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcDefinitionSelect > v5_RelatedObjects, ::Ifc4::IfcMaterialSelect v6_RelatingMaterial) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects));set_attribute_value(5, (v6_RelatingMaterial)); }
|
|
|
|
// Function implementations for IfcRelConnects
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelConnects::Class() { return *((IfcParse::entity*)IFC4_types[814]); }
|
|
void Ifc4::IfcRelConnects::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } }
|
|
|
|
// Function implementations for IfcRelConnectsElements
|
|
::Ifc4::IfcConnectionGeometry Ifc4::IfcRelConnectsElements::ConnectionGeometry() const { if(get_attribute_value(4).isNull()) { return ::Ifc4::IfcConnectionGeometry{}; } return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcConnectionGeometry>(); }
|
|
void Ifc4::IfcRelConnectsElements::setConnectionGeometry(const ::Ifc4::IfcConnectionGeometry& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcElement Ifc4::IfcRelConnectsElements::RelatingElement() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcElement>(); }
|
|
void Ifc4::IfcRelConnectsElements::setRelatingElement(const ::Ifc4::IfcElement& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
::Ifc4::IfcElement Ifc4::IfcRelConnectsElements::RelatedElement() const { return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcElement>(); }
|
|
void Ifc4::IfcRelConnectsElements::setRelatedElement(const ::Ifc4::IfcElement& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelConnectsElements::Class() { return *((IfcParse::entity*)IFC4_types[815]); }
|
|
void Ifc4::IfcRelConnectsElements::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcConnectionGeometry v5_ConnectionGeometry, ::Ifc4::IfcElement v6_RelatingElement, ::Ifc4::IfcElement v7_RelatedElement) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_ConnectionGeometry));set_attribute_value(5, (v6_RelatingElement));set_attribute_value(6, (v7_RelatedElement)); }
|
|
|
|
// Function implementations for IfcRelConnectsPathElements
|
|
std::vector< int > /*[0:?]*/ Ifc4::IfcRelConnectsPathElements::RelatingPriorities() const { std::vector< int > /*[0:?]*/ v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcRelConnectsPathElements::setRelatingPriorities(const std::vector< int > /*[0:?]*/& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
std::vector< int > /*[0:?]*/ Ifc4::IfcRelConnectsPathElements::RelatedPriorities() const { std::vector< int > /*[0:?]*/ v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcRelConnectsPathElements::setRelatedPriorities(const std::vector< int > /*[0:?]*/& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
::Ifc4::IfcConnectionTypeEnum::Value Ifc4::IfcRelConnectsPathElements::RelatedConnectionType() const { return ::Ifc4::IfcConnectionTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcRelConnectsPathElements::setRelatedConnectionType(const ::Ifc4::IfcConnectionTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcConnectionTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
::Ifc4::IfcConnectionTypeEnum::Value Ifc4::IfcRelConnectsPathElements::RelatingConnectionType() const { return ::Ifc4::IfcConnectionTypeEnum::FromString(get_attribute_value(10)); }
|
|
void Ifc4::IfcRelConnectsPathElements::setRelatingConnectionType(const ::Ifc4::IfcConnectionTypeEnum::Value& v) { set_attribute_value(10, EnumerationReference(&::Ifc4::IfcConnectionTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(10); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelConnectsPathElements::Class() { return *((IfcParse::entity*)IFC4_types[816]); }
|
|
void Ifc4::IfcRelConnectsPathElements::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcConnectionGeometry v5_ConnectionGeometry, ::Ifc4::IfcElement v6_RelatingElement, ::Ifc4::IfcElement v7_RelatedElement, std::vector< int > /*[0:?]*/ v8_RelatingPriorities, std::vector< int > /*[0:?]*/ v9_RelatedPriorities, ::Ifc4::IfcConnectionTypeEnum::Value v10_RelatedConnectionType, ::Ifc4::IfcConnectionTypeEnum::Value v11_RelatingConnectionType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_ConnectionGeometry));set_attribute_value(5, (v6_RelatingElement));set_attribute_value(6, (v7_RelatedElement));set_attribute_value(7, (v8_RelatingPriorities));set_attribute_value(8, (v9_RelatedPriorities));set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcConnectionTypeEnum::Class(),(size_t)v10_RelatedConnectionType)));set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcConnectionTypeEnum::Class(),(size_t)v11_RelatingConnectionType))); }
|
|
|
|
// Function implementations for IfcRelConnectsPortToElement
|
|
::Ifc4::IfcPort Ifc4::IfcRelConnectsPortToElement::RelatingPort() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcPort>(); }
|
|
void Ifc4::IfcRelConnectsPortToElement::setRelatingPort(const ::Ifc4::IfcPort& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcDistributionElement Ifc4::IfcRelConnectsPortToElement::RelatedElement() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcDistributionElement>(); }
|
|
void Ifc4::IfcRelConnectsPortToElement::setRelatedElement(const ::Ifc4::IfcDistributionElement& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelConnectsPortToElement::Class() { return *((IfcParse::entity*)IFC4_types[818]); }
|
|
void Ifc4::IfcRelConnectsPortToElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcPort v5_RelatingPort, ::Ifc4::IfcDistributionElement v6_RelatedElement) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingPort));set_attribute_value(5, (v6_RelatedElement)); }
|
|
|
|
// Function implementations for IfcRelConnectsPorts
|
|
::Ifc4::IfcPort Ifc4::IfcRelConnectsPorts::RelatingPort() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcPort>(); }
|
|
void Ifc4::IfcRelConnectsPorts::setRelatingPort(const ::Ifc4::IfcPort& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcPort Ifc4::IfcRelConnectsPorts::RelatedPort() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcPort>(); }
|
|
void Ifc4::IfcRelConnectsPorts::setRelatedPort(const ::Ifc4::IfcPort& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
::Ifc4::IfcElement Ifc4::IfcRelConnectsPorts::RealizingElement() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcElement{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcElement>(); }
|
|
void Ifc4::IfcRelConnectsPorts::setRealizingElement(const ::Ifc4::IfcElement& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelConnectsPorts::Class() { return *((IfcParse::entity*)IFC4_types[817]); }
|
|
void Ifc4::IfcRelConnectsPorts::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcPort v5_RelatingPort, ::Ifc4::IfcPort v6_RelatedPort, ::Ifc4::IfcElement v7_RealizingElement) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingPort));set_attribute_value(5, (v6_RelatedPort));set_attribute_value(6, (v7_RealizingElement)); }
|
|
|
|
// Function implementations for IfcRelConnectsStructuralActivity
|
|
::Ifc4::IfcStructuralActivityAssignmentSelect Ifc4::IfcRelConnectsStructuralActivity::RelatingElement() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcStructuralActivityAssignmentSelect>(); }
|
|
void Ifc4::IfcRelConnectsStructuralActivity::setRelatingElement(const ::Ifc4::IfcStructuralActivityAssignmentSelect& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcStructuralActivity Ifc4::IfcRelConnectsStructuralActivity::RelatedStructuralActivity() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcStructuralActivity>(); }
|
|
void Ifc4::IfcRelConnectsStructuralActivity::setRelatedStructuralActivity(const ::Ifc4::IfcStructuralActivity& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelConnectsStructuralActivity::Class() { return *((IfcParse::entity*)IFC4_types[819]); }
|
|
void Ifc4::IfcRelConnectsStructuralActivity::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcStructuralActivityAssignmentSelect v5_RelatingElement, ::Ifc4::IfcStructuralActivity v6_RelatedStructuralActivity) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingElement));set_attribute_value(5, (v6_RelatedStructuralActivity)); }
|
|
|
|
// Function implementations for IfcRelConnectsStructuralMember
|
|
::Ifc4::IfcStructuralMember Ifc4::IfcRelConnectsStructuralMember::RelatingStructuralMember() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcStructuralMember>(); }
|
|
void Ifc4::IfcRelConnectsStructuralMember::setRelatingStructuralMember(const ::Ifc4::IfcStructuralMember& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcStructuralConnection Ifc4::IfcRelConnectsStructuralMember::RelatedStructuralConnection() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcStructuralConnection>(); }
|
|
void Ifc4::IfcRelConnectsStructuralMember::setRelatedStructuralConnection(const ::Ifc4::IfcStructuralConnection& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
::Ifc4::IfcBoundaryCondition Ifc4::IfcRelConnectsStructuralMember::AppliedCondition() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcBoundaryCondition{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcBoundaryCondition>(); }
|
|
void Ifc4::IfcRelConnectsStructuralMember::setAppliedCondition(const ::Ifc4::IfcBoundaryCondition& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
::Ifc4::IfcStructuralConnectionCondition Ifc4::IfcRelConnectsStructuralMember::AdditionalConditions() const { if(get_attribute_value(7).isNull()) { return ::Ifc4::IfcStructuralConnectionCondition{}; } return ((express::Base)(get_attribute_value(7))).as<::Ifc4::IfcStructuralConnectionCondition>(); }
|
|
void Ifc4::IfcRelConnectsStructuralMember::setAdditionalConditions(const ::Ifc4::IfcStructuralConnectionCondition& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
std::optional< double > Ifc4::IfcRelConnectsStructuralMember::SupportedLength() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } double v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcRelConnectsStructuralMember::setSupportedLength(const std::optional< double >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
::Ifc4::IfcAxis2Placement3D Ifc4::IfcRelConnectsStructuralMember::ConditionCoordinateSystem() const { if(get_attribute_value(9).isNull()) { return ::Ifc4::IfcAxis2Placement3D{}; } return ((express::Base)(get_attribute_value(9))).as<::Ifc4::IfcAxis2Placement3D>(); }
|
|
void Ifc4::IfcRelConnectsStructuralMember::setConditionCoordinateSystem(const ::Ifc4::IfcAxis2Placement3D& v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelConnectsStructuralMember::Class() { return *((IfcParse::entity*)IFC4_types[820]); }
|
|
void Ifc4::IfcRelConnectsStructuralMember::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcStructuralMember v5_RelatingStructuralMember, ::Ifc4::IfcStructuralConnection v6_RelatedStructuralConnection, ::Ifc4::IfcBoundaryCondition v7_AppliedCondition, ::Ifc4::IfcStructuralConnectionCondition v8_AdditionalConditions, std::optional< double > v9_SupportedLength, ::Ifc4::IfcAxis2Placement3D v10_ConditionCoordinateSystem) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingStructuralMember));set_attribute_value(5, (v6_RelatedStructuralConnection));set_attribute_value(6, (v7_AppliedCondition));set_attribute_value(7, (v8_AdditionalConditions)); if (v9_SupportedLength) {set_attribute_value(8, (*v9_SupportedLength)); }set_attribute_value(9, (v10_ConditionCoordinateSystem)); }
|
|
|
|
// Function implementations for IfcRelConnectsWithEccentricity
|
|
::Ifc4::IfcConnectionGeometry Ifc4::IfcRelConnectsWithEccentricity::ConnectionConstraint() const { return ((express::Base)(get_attribute_value(10))).as<::Ifc4::IfcConnectionGeometry>(); }
|
|
void Ifc4::IfcRelConnectsWithEccentricity::setConnectionConstraint(const ::Ifc4::IfcConnectionGeometry& v) { set_attribute_value(10, v);if constexpr (false)unset_attribute_value(10); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelConnectsWithEccentricity::Class() { return *((IfcParse::entity*)IFC4_types[821]); }
|
|
void Ifc4::IfcRelConnectsWithEccentricity::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcStructuralMember v5_RelatingStructuralMember, ::Ifc4::IfcStructuralConnection v6_RelatedStructuralConnection, ::Ifc4::IfcBoundaryCondition v7_AppliedCondition, ::Ifc4::IfcStructuralConnectionCondition v8_AdditionalConditions, std::optional< double > v9_SupportedLength, ::Ifc4::IfcAxis2Placement3D v10_ConditionCoordinateSystem, ::Ifc4::IfcConnectionGeometry v11_ConnectionConstraint) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingStructuralMember));set_attribute_value(5, (v6_RelatedStructuralConnection));set_attribute_value(6, (v7_AppliedCondition));set_attribute_value(7, (v8_AdditionalConditions)); if (v9_SupportedLength) {set_attribute_value(8, (*v9_SupportedLength)); }set_attribute_value(9, (v10_ConditionCoordinateSystem));set_attribute_value(10, (v11_ConnectionConstraint)); }
|
|
|
|
// Function implementations for IfcRelConnectsWithRealizingElements
|
|
std::vector< ::Ifc4::IfcElement > Ifc4::IfcRelConnectsWithRealizingElements::RealizingElements() const { std::vector<express::Base> es = get_attribute_value(7); return cast_vector<::Ifc4::IfcElement>(es); }
|
|
void Ifc4::IfcRelConnectsWithRealizingElements::setRealizingElements(const std::vector< ::Ifc4::IfcElement >& v) { set_attribute_value(7, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(7); }
|
|
std::optional< std::string > Ifc4::IfcRelConnectsWithRealizingElements::ConnectionType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcRelConnectsWithRealizingElements::setConnectionType(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelConnectsWithRealizingElements::Class() { return *((IfcParse::entity*)IFC4_types[822]); }
|
|
void Ifc4::IfcRelConnectsWithRealizingElements::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcConnectionGeometry v5_ConnectionGeometry, ::Ifc4::IfcElement v6_RelatingElement, ::Ifc4::IfcElement v7_RelatedElement, std::vector< ::Ifc4::IfcElement > v8_RealizingElements, std::optional< std::string > v9_ConnectionType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_ConnectionGeometry));set_attribute_value(5, (v6_RelatingElement));set_attribute_value(6, (v7_RelatedElement));set_attribute_value(7, cast_vector<express::Base>(v8_RealizingElements)); if (v9_ConnectionType) {set_attribute_value(8, (*v9_ConnectionType)); } }
|
|
|
|
// Function implementations for IfcRelContainedInSpatialStructure
|
|
std::vector< ::Ifc4::IfcProduct > Ifc4::IfcRelContainedInSpatialStructure::RelatedElements() const { std::vector<express::Base> es = get_attribute_value(4); return cast_vector<::Ifc4::IfcProduct>(es); }
|
|
void Ifc4::IfcRelContainedInSpatialStructure::setRelatedElements(const std::vector< ::Ifc4::IfcProduct >& v) { set_attribute_value(4, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcSpatialElement Ifc4::IfcRelContainedInSpatialStructure::RelatingStructure() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcSpatialElement>(); }
|
|
void Ifc4::IfcRelContainedInSpatialStructure::setRelatingStructure(const ::Ifc4::IfcSpatialElement& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelContainedInSpatialStructure::Class() { return *((IfcParse::entity*)IFC4_types[823]); }
|
|
void Ifc4::IfcRelContainedInSpatialStructure::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcProduct > v5_RelatedElements, ::Ifc4::IfcSpatialElement v6_RelatingStructure) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedElements));set_attribute_value(5, (v6_RelatingStructure)); }
|
|
|
|
// Function implementations for IfcRelCoversBldgElements
|
|
::Ifc4::IfcElement Ifc4::IfcRelCoversBldgElements::RelatingBuildingElement() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcElement>(); }
|
|
void Ifc4::IfcRelCoversBldgElements::setRelatingBuildingElement(const ::Ifc4::IfcElement& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
std::vector< ::Ifc4::IfcCovering > Ifc4::IfcRelCoversBldgElements::RelatedCoverings() const { std::vector<express::Base> es = get_attribute_value(5); return cast_vector<::Ifc4::IfcCovering>(es); }
|
|
void Ifc4::IfcRelCoversBldgElements::setRelatedCoverings(const std::vector< ::Ifc4::IfcCovering >& v) { set_attribute_value(5, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelCoversBldgElements::Class() { return *((IfcParse::entity*)IFC4_types[824]); }
|
|
void Ifc4::IfcRelCoversBldgElements::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcElement v5_RelatingBuildingElement, std::vector< ::Ifc4::IfcCovering > v6_RelatedCoverings) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingBuildingElement));set_attribute_value(5, cast_vector<express::Base>(v6_RelatedCoverings)); }
|
|
|
|
// Function implementations for IfcRelCoversSpaces
|
|
::Ifc4::IfcSpace Ifc4::IfcRelCoversSpaces::RelatingSpace() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcSpace>(); }
|
|
void Ifc4::IfcRelCoversSpaces::setRelatingSpace(const ::Ifc4::IfcSpace& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
std::vector< ::Ifc4::IfcCovering > Ifc4::IfcRelCoversSpaces::RelatedCoverings() const { std::vector<express::Base> es = get_attribute_value(5); return cast_vector<::Ifc4::IfcCovering>(es); }
|
|
void Ifc4::IfcRelCoversSpaces::setRelatedCoverings(const std::vector< ::Ifc4::IfcCovering >& v) { set_attribute_value(5, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelCoversSpaces::Class() { return *((IfcParse::entity*)IFC4_types[825]); }
|
|
void Ifc4::IfcRelCoversSpaces::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcSpace v5_RelatingSpace, std::vector< ::Ifc4::IfcCovering > v6_RelatedCoverings) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingSpace));set_attribute_value(5, cast_vector<express::Base>(v6_RelatedCoverings)); }
|
|
|
|
// Function implementations for IfcRelDeclares
|
|
::Ifc4::IfcContext Ifc4::IfcRelDeclares::RelatingContext() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcContext>(); }
|
|
void Ifc4::IfcRelDeclares::setRelatingContext(const ::Ifc4::IfcContext& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
std::vector< ::Ifc4::IfcDefinitionSelect > Ifc4::IfcRelDeclares::RelatedDefinitions() const { std::vector<express::Base> es = get_attribute_value(5); return cast_vector<::Ifc4::IfcDefinitionSelect>(es); }
|
|
void Ifc4::IfcRelDeclares::setRelatedDefinitions(const std::vector< ::Ifc4::IfcDefinitionSelect >& v) { set_attribute_value(5, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelDeclares::Class() { return *((IfcParse::entity*)IFC4_types[826]); }
|
|
void Ifc4::IfcRelDeclares::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcContext v5_RelatingContext, std::vector< ::Ifc4::IfcDefinitionSelect > v6_RelatedDefinitions) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingContext));set_attribute_value(5, cast_vector<express::Base>(v6_RelatedDefinitions)); }
|
|
|
|
// Function implementations for IfcRelDecomposes
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelDecomposes::Class() { return *((IfcParse::entity*)IFC4_types[827]); }
|
|
void Ifc4::IfcRelDecomposes::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } }
|
|
|
|
// Function implementations for IfcRelDefines
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelDefines::Class() { return *((IfcParse::entity*)IFC4_types[828]); }
|
|
void Ifc4::IfcRelDefines::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } }
|
|
|
|
// Function implementations for IfcRelDefinesByObject
|
|
std::vector< ::Ifc4::IfcObject > Ifc4::IfcRelDefinesByObject::RelatedObjects() const { std::vector<express::Base> es = get_attribute_value(4); return cast_vector<::Ifc4::IfcObject>(es); }
|
|
void Ifc4::IfcRelDefinesByObject::setRelatedObjects(const std::vector< ::Ifc4::IfcObject >& v) { set_attribute_value(4, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcObject Ifc4::IfcRelDefinesByObject::RelatingObject() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcObject>(); }
|
|
void Ifc4::IfcRelDefinesByObject::setRelatingObject(const ::Ifc4::IfcObject& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelDefinesByObject::Class() { return *((IfcParse::entity*)IFC4_types[829]); }
|
|
void Ifc4::IfcRelDefinesByObject::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcObject > v5_RelatedObjects, ::Ifc4::IfcObject v6_RelatingObject) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects));set_attribute_value(5, (v6_RelatingObject)); }
|
|
|
|
// Function implementations for IfcRelDefinesByProperties
|
|
std::vector< ::Ifc4::IfcObjectDefinition > Ifc4::IfcRelDefinesByProperties::RelatedObjects() const { std::vector<express::Base> es = get_attribute_value(4); return cast_vector<::Ifc4::IfcObjectDefinition>(es); }
|
|
void Ifc4::IfcRelDefinesByProperties::setRelatedObjects(const std::vector< ::Ifc4::IfcObjectDefinition >& v) { set_attribute_value(4, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcPropertySetDefinitionSelect Ifc4::IfcRelDefinesByProperties::RelatingPropertyDefinition() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcPropertySetDefinitionSelect>(); }
|
|
void Ifc4::IfcRelDefinesByProperties::setRelatingPropertyDefinition(const ::Ifc4::IfcPropertySetDefinitionSelect& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelDefinesByProperties::Class() { return *((IfcParse::entity*)IFC4_types[830]); }
|
|
void Ifc4::IfcRelDefinesByProperties::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcObjectDefinition > v5_RelatedObjects, ::Ifc4::IfcPropertySetDefinitionSelect v6_RelatingPropertyDefinition) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects));set_attribute_value(5, (v6_RelatingPropertyDefinition)); }
|
|
|
|
// Function implementations for IfcRelDefinesByTemplate
|
|
std::vector< ::Ifc4::IfcPropertySetDefinition > Ifc4::IfcRelDefinesByTemplate::RelatedPropertySets() const { std::vector<express::Base> es = get_attribute_value(4); return cast_vector<::Ifc4::IfcPropertySetDefinition>(es); }
|
|
void Ifc4::IfcRelDefinesByTemplate::setRelatedPropertySets(const std::vector< ::Ifc4::IfcPropertySetDefinition >& v) { set_attribute_value(4, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcPropertySetTemplate Ifc4::IfcRelDefinesByTemplate::RelatingTemplate() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcPropertySetTemplate>(); }
|
|
void Ifc4::IfcRelDefinesByTemplate::setRelatingTemplate(const ::Ifc4::IfcPropertySetTemplate& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelDefinesByTemplate::Class() { return *((IfcParse::entity*)IFC4_types[831]); }
|
|
void Ifc4::IfcRelDefinesByTemplate::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcPropertySetDefinition > v5_RelatedPropertySets, ::Ifc4::IfcPropertySetTemplate v6_RelatingTemplate) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedPropertySets));set_attribute_value(5, (v6_RelatingTemplate)); }
|
|
|
|
// Function implementations for IfcRelDefinesByType
|
|
std::vector< ::Ifc4::IfcObject > Ifc4::IfcRelDefinesByType::RelatedObjects() const { std::vector<express::Base> es = get_attribute_value(4); return cast_vector<::Ifc4::IfcObject>(es); }
|
|
void Ifc4::IfcRelDefinesByType::setRelatedObjects(const std::vector< ::Ifc4::IfcObject >& v) { set_attribute_value(4, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcTypeObject Ifc4::IfcRelDefinesByType::RelatingType() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcTypeObject>(); }
|
|
void Ifc4::IfcRelDefinesByType::setRelatingType(const ::Ifc4::IfcTypeObject& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelDefinesByType::Class() { return *((IfcParse::entity*)IFC4_types[832]); }
|
|
void Ifc4::IfcRelDefinesByType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcObject > v5_RelatedObjects, ::Ifc4::IfcTypeObject v6_RelatingType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedObjects));set_attribute_value(5, (v6_RelatingType)); }
|
|
|
|
// Function implementations for IfcRelFillsElement
|
|
::Ifc4::IfcOpeningElement Ifc4::IfcRelFillsElement::RelatingOpeningElement() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcOpeningElement>(); }
|
|
void Ifc4::IfcRelFillsElement::setRelatingOpeningElement(const ::Ifc4::IfcOpeningElement& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcElement Ifc4::IfcRelFillsElement::RelatedBuildingElement() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcElement>(); }
|
|
void Ifc4::IfcRelFillsElement::setRelatedBuildingElement(const ::Ifc4::IfcElement& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelFillsElement::Class() { return *((IfcParse::entity*)IFC4_types[833]); }
|
|
void Ifc4::IfcRelFillsElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcOpeningElement v5_RelatingOpeningElement, ::Ifc4::IfcElement v6_RelatedBuildingElement) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingOpeningElement));set_attribute_value(5, (v6_RelatedBuildingElement)); }
|
|
|
|
// Function implementations for IfcRelFlowControlElements
|
|
std::vector< ::Ifc4::IfcDistributionControlElement > Ifc4::IfcRelFlowControlElements::RelatedControlElements() const { std::vector<express::Base> es = get_attribute_value(4); return cast_vector<::Ifc4::IfcDistributionControlElement>(es); }
|
|
void Ifc4::IfcRelFlowControlElements::setRelatedControlElements(const std::vector< ::Ifc4::IfcDistributionControlElement >& v) { set_attribute_value(4, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcDistributionFlowElement Ifc4::IfcRelFlowControlElements::RelatingFlowElement() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcDistributionFlowElement>(); }
|
|
void Ifc4::IfcRelFlowControlElements::setRelatingFlowElement(const ::Ifc4::IfcDistributionFlowElement& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelFlowControlElements::Class() { return *((IfcParse::entity*)IFC4_types[834]); }
|
|
void Ifc4::IfcRelFlowControlElements::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcDistributionControlElement > v5_RelatedControlElements, ::Ifc4::IfcDistributionFlowElement v6_RelatingFlowElement) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedControlElements));set_attribute_value(5, (v6_RelatingFlowElement)); }
|
|
|
|
// Function implementations for IfcRelInterferesElements
|
|
::Ifc4::IfcElement Ifc4::IfcRelInterferesElements::RelatingElement() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcElement>(); }
|
|
void Ifc4::IfcRelInterferesElements::setRelatingElement(const ::Ifc4::IfcElement& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcElement Ifc4::IfcRelInterferesElements::RelatedElement() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcElement>(); }
|
|
void Ifc4::IfcRelInterferesElements::setRelatedElement(const ::Ifc4::IfcElement& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
::Ifc4::IfcConnectionGeometry Ifc4::IfcRelInterferesElements::InterferenceGeometry() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcConnectionGeometry{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcConnectionGeometry>(); }
|
|
void Ifc4::IfcRelInterferesElements::setInterferenceGeometry(const ::Ifc4::IfcConnectionGeometry& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
std::optional< std::string > Ifc4::IfcRelInterferesElements::InterferenceType() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::string v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcRelInterferesElements::setInterferenceType(const std::optional< std::string >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
boost::logic::tribool Ifc4::IfcRelInterferesElements::ImpliedOrder() const { boost::logic::tribool v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcRelInterferesElements::setImpliedOrder(const boost::logic::tribool& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelInterferesElements::Class() { return *((IfcParse::entity*)IFC4_types[835]); }
|
|
void Ifc4::IfcRelInterferesElements::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcElement v5_RelatingElement, ::Ifc4::IfcElement v6_RelatedElement, ::Ifc4::IfcConnectionGeometry v7_InterferenceGeometry, std::optional< std::string > v8_InterferenceType, boost::logic::tribool v9_ImpliedOrder) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingElement));set_attribute_value(5, (v6_RelatedElement));set_attribute_value(6, (v7_InterferenceGeometry)); if (v8_InterferenceType) {set_attribute_value(7, (*v8_InterferenceType)); }set_attribute_value(8, (v9_ImpliedOrder)); }
|
|
|
|
// Function implementations for IfcRelNests
|
|
::Ifc4::IfcObjectDefinition Ifc4::IfcRelNests::RelatingObject() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcObjectDefinition>(); }
|
|
void Ifc4::IfcRelNests::setRelatingObject(const ::Ifc4::IfcObjectDefinition& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
std::vector< ::Ifc4::IfcObjectDefinition > Ifc4::IfcRelNests::RelatedObjects() const { std::vector<express::Base> es = get_attribute_value(5); return cast_vector<::Ifc4::IfcObjectDefinition>(es); }
|
|
void Ifc4::IfcRelNests::setRelatedObjects(const std::vector< ::Ifc4::IfcObjectDefinition >& v) { set_attribute_value(5, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelNests::Class() { return *((IfcParse::entity*)IFC4_types[836]); }
|
|
void Ifc4::IfcRelNests::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcObjectDefinition v5_RelatingObject, std::vector< ::Ifc4::IfcObjectDefinition > v6_RelatedObjects) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingObject));set_attribute_value(5, cast_vector<express::Base>(v6_RelatedObjects)); }
|
|
|
|
// Function implementations for IfcRelProjectsElement
|
|
::Ifc4::IfcElement Ifc4::IfcRelProjectsElement::RelatingElement() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcElement>(); }
|
|
void Ifc4::IfcRelProjectsElement::setRelatingElement(const ::Ifc4::IfcElement& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcFeatureElementAddition Ifc4::IfcRelProjectsElement::RelatedFeatureElement() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcFeatureElementAddition>(); }
|
|
void Ifc4::IfcRelProjectsElement::setRelatedFeatureElement(const ::Ifc4::IfcFeatureElementAddition& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelProjectsElement::Class() { return *((IfcParse::entity*)IFC4_types[837]); }
|
|
void Ifc4::IfcRelProjectsElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcElement v5_RelatingElement, ::Ifc4::IfcFeatureElementAddition v6_RelatedFeatureElement) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingElement));set_attribute_value(5, (v6_RelatedFeatureElement)); }
|
|
|
|
// Function implementations for IfcRelReferencedInSpatialStructure
|
|
std::vector< ::Ifc4::IfcProduct > Ifc4::IfcRelReferencedInSpatialStructure::RelatedElements() const { std::vector<express::Base> es = get_attribute_value(4); return cast_vector<::Ifc4::IfcProduct>(es); }
|
|
void Ifc4::IfcRelReferencedInSpatialStructure::setRelatedElements(const std::vector< ::Ifc4::IfcProduct >& v) { set_attribute_value(4, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcSpatialElement Ifc4::IfcRelReferencedInSpatialStructure::RelatingStructure() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcSpatialElement>(); }
|
|
void Ifc4::IfcRelReferencedInSpatialStructure::setRelatingStructure(const ::Ifc4::IfcSpatialElement& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelReferencedInSpatialStructure::Class() { return *((IfcParse::entity*)IFC4_types[838]); }
|
|
void Ifc4::IfcRelReferencedInSpatialStructure::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::vector< ::Ifc4::IfcProduct > v5_RelatedElements, ::Ifc4::IfcSpatialElement v6_RelatingStructure) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, cast_vector<express::Base>(v5_RelatedElements));set_attribute_value(5, (v6_RelatingStructure)); }
|
|
|
|
// Function implementations for IfcRelSequence
|
|
::Ifc4::IfcProcess Ifc4::IfcRelSequence::RelatingProcess() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcProcess>(); }
|
|
void Ifc4::IfcRelSequence::setRelatingProcess(const ::Ifc4::IfcProcess& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcProcess Ifc4::IfcRelSequence::RelatedProcess() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcProcess>(); }
|
|
void Ifc4::IfcRelSequence::setRelatedProcess(const ::Ifc4::IfcProcess& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
::Ifc4::IfcLagTime Ifc4::IfcRelSequence::TimeLag() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcLagTime{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcLagTime>(); }
|
|
void Ifc4::IfcRelSequence::setTimeLag(const ::Ifc4::IfcLagTime& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
std::optional< ::Ifc4::IfcSequenceEnum::Value > Ifc4::IfcRelSequence::SequenceType() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } return ::Ifc4::IfcSequenceEnum::FromString(get_attribute_value(7)); }
|
|
void Ifc4::IfcRelSequence::setSequenceType(const std::optional< ::Ifc4::IfcSequenceEnum::Value >& v) { if (v) {set_attribute_value(7, EnumerationReference(&::Ifc4::IfcSequenceEnum::Class(), (size_t) *v));} else {unset_attribute_value(7);} }
|
|
std::optional< std::string > Ifc4::IfcRelSequence::UserDefinedSequenceType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcRelSequence::setUserDefinedSequenceType(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelSequence::Class() { return *((IfcParse::entity*)IFC4_types[839]); }
|
|
void Ifc4::IfcRelSequence::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcProcess v5_RelatingProcess, ::Ifc4::IfcProcess v6_RelatedProcess, ::Ifc4::IfcLagTime v7_TimeLag, std::optional< ::Ifc4::IfcSequenceEnum::Value > v8_SequenceType, std::optional< std::string > v9_UserDefinedSequenceType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingProcess));set_attribute_value(5, (v6_RelatedProcess));set_attribute_value(6, (v7_TimeLag)); if (v8_SequenceType) {set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcSequenceEnum::Class(),(size_t)*v8_SequenceType))); } if (v9_UserDefinedSequenceType) {set_attribute_value(8, (*v9_UserDefinedSequenceType)); } }
|
|
|
|
// Function implementations for IfcRelServicesBuildings
|
|
::Ifc4::IfcSystem Ifc4::IfcRelServicesBuildings::RelatingSystem() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcSystem>(); }
|
|
void Ifc4::IfcRelServicesBuildings::setRelatingSystem(const ::Ifc4::IfcSystem& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
std::vector< ::Ifc4::IfcSpatialElement > Ifc4::IfcRelServicesBuildings::RelatedBuildings() const { std::vector<express::Base> es = get_attribute_value(5); return cast_vector<::Ifc4::IfcSpatialElement>(es); }
|
|
void Ifc4::IfcRelServicesBuildings::setRelatedBuildings(const std::vector< ::Ifc4::IfcSpatialElement >& v) { set_attribute_value(5, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelServicesBuildings::Class() { return *((IfcParse::entity*)IFC4_types[840]); }
|
|
void Ifc4::IfcRelServicesBuildings::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcSystem v5_RelatingSystem, std::vector< ::Ifc4::IfcSpatialElement > v6_RelatedBuildings) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingSystem));set_attribute_value(5, cast_vector<express::Base>(v6_RelatedBuildings)); }
|
|
|
|
// Function implementations for IfcRelSpaceBoundary
|
|
::Ifc4::IfcSpaceBoundarySelect Ifc4::IfcRelSpaceBoundary::RelatingSpace() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcSpaceBoundarySelect>(); }
|
|
void Ifc4::IfcRelSpaceBoundary::setRelatingSpace(const ::Ifc4::IfcSpaceBoundarySelect& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcElement Ifc4::IfcRelSpaceBoundary::RelatedBuildingElement() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcElement>(); }
|
|
void Ifc4::IfcRelSpaceBoundary::setRelatedBuildingElement(const ::Ifc4::IfcElement& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
::Ifc4::IfcConnectionGeometry Ifc4::IfcRelSpaceBoundary::ConnectionGeometry() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcConnectionGeometry{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcConnectionGeometry>(); }
|
|
void Ifc4::IfcRelSpaceBoundary::setConnectionGeometry(const ::Ifc4::IfcConnectionGeometry& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
::Ifc4::IfcPhysicalOrVirtualEnum::Value Ifc4::IfcRelSpaceBoundary::PhysicalOrVirtualBoundary() const { return ::Ifc4::IfcPhysicalOrVirtualEnum::FromString(get_attribute_value(7)); }
|
|
void Ifc4::IfcRelSpaceBoundary::setPhysicalOrVirtualBoundary(const ::Ifc4::IfcPhysicalOrVirtualEnum::Value& v) { set_attribute_value(7, EnumerationReference(&::Ifc4::IfcPhysicalOrVirtualEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }
|
|
::Ifc4::IfcInternalOrExternalEnum::Value Ifc4::IfcRelSpaceBoundary::InternalOrExternalBoundary() const { return ::Ifc4::IfcInternalOrExternalEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcRelSpaceBoundary::setInternalOrExternalBoundary(const ::Ifc4::IfcInternalOrExternalEnum::Value& v) { set_attribute_value(8, EnumerationReference(&::Ifc4::IfcInternalOrExternalEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelSpaceBoundary::Class() { return *((IfcParse::entity*)IFC4_types[841]); }
|
|
void Ifc4::IfcRelSpaceBoundary::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcSpaceBoundarySelect v5_RelatingSpace, ::Ifc4::IfcElement v6_RelatedBuildingElement, ::Ifc4::IfcConnectionGeometry v7_ConnectionGeometry, ::Ifc4::IfcPhysicalOrVirtualEnum::Value v8_PhysicalOrVirtualBoundary, ::Ifc4::IfcInternalOrExternalEnum::Value v9_InternalOrExternalBoundary) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingSpace));set_attribute_value(5, (v6_RelatedBuildingElement));set_attribute_value(6, (v7_ConnectionGeometry));set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcPhysicalOrVirtualEnum::Class(),(size_t)v8_PhysicalOrVirtualBoundary)));set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcInternalOrExternalEnum::Class(),(size_t)v9_InternalOrExternalBoundary))); }
|
|
|
|
// Function implementations for IfcRelSpaceBoundary1stLevel
|
|
::Ifc4::IfcRelSpaceBoundary1stLevel Ifc4::IfcRelSpaceBoundary1stLevel::ParentBoundary() const { if(get_attribute_value(9).isNull()) { return ::Ifc4::IfcRelSpaceBoundary1stLevel{}; } return ((express::Base)(get_attribute_value(9))).as<::Ifc4::IfcRelSpaceBoundary1stLevel>(); }
|
|
void Ifc4::IfcRelSpaceBoundary1stLevel::setParentBoundary(const ::Ifc4::IfcRelSpaceBoundary1stLevel& v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }
|
|
|
|
std::vector<::Ifc4::IfcRelSpaceBoundary1stLevel> Ifc4::IfcRelSpaceBoundary1stLevel::InnerBoundaries() const { return cast_vector<IfcRelSpaceBoundary1stLevel>(file()->getInverse(data()->id(), IFC4_types[842], 9)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelSpaceBoundary1stLevel::Class() { return *((IfcParse::entity*)IFC4_types[842]); }
|
|
void Ifc4::IfcRelSpaceBoundary1stLevel::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcSpaceBoundarySelect v5_RelatingSpace, ::Ifc4::IfcElement v6_RelatedBuildingElement, ::Ifc4::IfcConnectionGeometry v7_ConnectionGeometry, ::Ifc4::IfcPhysicalOrVirtualEnum::Value v8_PhysicalOrVirtualBoundary, ::Ifc4::IfcInternalOrExternalEnum::Value v9_InternalOrExternalBoundary, ::Ifc4::IfcRelSpaceBoundary1stLevel v10_ParentBoundary) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingSpace));set_attribute_value(5, (v6_RelatedBuildingElement));set_attribute_value(6, (v7_ConnectionGeometry));set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcPhysicalOrVirtualEnum::Class(),(size_t)v8_PhysicalOrVirtualBoundary)));set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcInternalOrExternalEnum::Class(),(size_t)v9_InternalOrExternalBoundary)));set_attribute_value(9, (v10_ParentBoundary)); }
|
|
|
|
// Function implementations for IfcRelSpaceBoundary2ndLevel
|
|
::Ifc4::IfcRelSpaceBoundary2ndLevel Ifc4::IfcRelSpaceBoundary2ndLevel::CorrespondingBoundary() const { if(get_attribute_value(10).isNull()) { return ::Ifc4::IfcRelSpaceBoundary2ndLevel{}; } return ((express::Base)(get_attribute_value(10))).as<::Ifc4::IfcRelSpaceBoundary2ndLevel>(); }
|
|
void Ifc4::IfcRelSpaceBoundary2ndLevel::setCorrespondingBoundary(const ::Ifc4::IfcRelSpaceBoundary2ndLevel& v) { set_attribute_value(10, v);if constexpr (false)unset_attribute_value(10); }
|
|
|
|
std::vector<::Ifc4::IfcRelSpaceBoundary2ndLevel> Ifc4::IfcRelSpaceBoundary2ndLevel::Corresponds() const { return cast_vector<IfcRelSpaceBoundary2ndLevel>(file()->getInverse(data()->id(), IFC4_types[843], 10)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelSpaceBoundary2ndLevel::Class() { return *((IfcParse::entity*)IFC4_types[843]); }
|
|
void Ifc4::IfcRelSpaceBoundary2ndLevel::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcSpaceBoundarySelect v5_RelatingSpace, ::Ifc4::IfcElement v6_RelatedBuildingElement, ::Ifc4::IfcConnectionGeometry v7_ConnectionGeometry, ::Ifc4::IfcPhysicalOrVirtualEnum::Value v8_PhysicalOrVirtualBoundary, ::Ifc4::IfcInternalOrExternalEnum::Value v9_InternalOrExternalBoundary, ::Ifc4::IfcRelSpaceBoundary1stLevel v10_ParentBoundary, ::Ifc4::IfcRelSpaceBoundary2ndLevel v11_CorrespondingBoundary) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingSpace));set_attribute_value(5, (v6_RelatedBuildingElement));set_attribute_value(6, (v7_ConnectionGeometry));set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcPhysicalOrVirtualEnum::Class(),(size_t)v8_PhysicalOrVirtualBoundary)));set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcInternalOrExternalEnum::Class(),(size_t)v9_InternalOrExternalBoundary)));set_attribute_value(9, (v10_ParentBoundary));set_attribute_value(10, (v11_CorrespondingBoundary)); }
|
|
|
|
// Function implementations for IfcRelVoidsElement
|
|
::Ifc4::IfcElement Ifc4::IfcRelVoidsElement::RelatingBuildingElement() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcElement>(); }
|
|
void Ifc4::IfcRelVoidsElement::setRelatingBuildingElement(const ::Ifc4::IfcElement& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcFeatureElementSubtraction Ifc4::IfcRelVoidsElement::RelatedOpeningElement() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcFeatureElementSubtraction>(); }
|
|
void Ifc4::IfcRelVoidsElement::setRelatedOpeningElement(const ::Ifc4::IfcFeatureElementSubtraction& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelVoidsElement::Class() { return *((IfcParse::entity*)IFC4_types[844]); }
|
|
void Ifc4::IfcRelVoidsElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcElement v5_RelatingBuildingElement, ::Ifc4::IfcFeatureElementSubtraction v6_RelatedOpeningElement) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (v5_RelatingBuildingElement));set_attribute_value(5, (v6_RelatedOpeningElement)); }
|
|
|
|
// Function implementations for IfcRelationship
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRelationship::Class() { return *((IfcParse::entity*)IFC4_types[813]); }
|
|
void Ifc4::IfcRelationship::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } }
|
|
|
|
// Function implementations for IfcReparametrisedCompositeCurveSegment
|
|
double Ifc4::IfcReparametrisedCompositeCurveSegment::ParamLength() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcReparametrisedCompositeCurveSegment::setParamLength(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcReparametrisedCompositeCurveSegment::Class() { return *((IfcParse::entity*)IFC4_types[845]); }
|
|
void Ifc4::IfcReparametrisedCompositeCurveSegment::initialize(::Ifc4::IfcTransitionCode::Value v1_Transition, bool v2_SameSense, ::Ifc4::IfcCurve v3_ParentCurve, double v4_ParamLength) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcTransitionCode::Class(),(size_t)v1_Transition)));set_attribute_value(1, (v2_SameSense));set_attribute_value(2, (v3_ParentCurve));set_attribute_value(3, (v4_ParamLength)); }
|
|
|
|
// Function implementations for IfcRepresentation
|
|
::Ifc4::IfcRepresentationContext Ifc4::IfcRepresentation::ContextOfItems() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcRepresentationContext>(); }
|
|
void Ifc4::IfcRepresentation::setContextOfItems(const ::Ifc4::IfcRepresentationContext& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< std::string > Ifc4::IfcRepresentation::RepresentationIdentifier() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcRepresentation::setRepresentationIdentifier(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< std::string > Ifc4::IfcRepresentation::RepresentationType() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcRepresentation::setRepresentationType(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::vector< ::Ifc4::IfcRepresentationItem > Ifc4::IfcRepresentation::Items() const { std::vector<express::Base> es = get_attribute_value(3); return cast_vector<::Ifc4::IfcRepresentationItem>(es); }
|
|
void Ifc4::IfcRepresentation::setItems(const std::vector< ::Ifc4::IfcRepresentationItem >& v) { set_attribute_value(3, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(3); }
|
|
|
|
std::vector<::Ifc4::IfcRepresentationMap> Ifc4::IfcRepresentation::RepresentationMap() const { return cast_vector<IfcRepresentationMap>(file()->getInverse(data()->id(), IFC4_types[849], 1)); }
|
|
std::vector<::Ifc4::IfcPresentationLayerAssignment> Ifc4::IfcRepresentation::LayerAssignments() const { return cast_vector<IfcPresentationLayerAssignment>(file()->getInverse(data()->id(), IFC4_types[699], 2)); }
|
|
std::vector<::Ifc4::IfcProductRepresentation> Ifc4::IfcRepresentation::OfProductRepresentation() const { return cast_vector<IfcProductRepresentation>(file()->getInverse(data()->id(), IFC4_types[712], 2)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcRepresentation::Class() { return *((IfcParse::entity*)IFC4_types[846]); }
|
|
void Ifc4::IfcRepresentation::initialize(::Ifc4::IfcRepresentationContext v1_ContextOfItems, std::optional< std::string > v2_RepresentationIdentifier, std::optional< std::string > v3_RepresentationType, std::vector< ::Ifc4::IfcRepresentationItem > v4_Items) { set_attribute_value(0, (v1_ContextOfItems)); if (v2_RepresentationIdentifier) {set_attribute_value(1, (*v2_RepresentationIdentifier)); } if (v3_RepresentationType) {set_attribute_value(2, (*v3_RepresentationType)); }set_attribute_value(3, cast_vector<express::Base>(v4_Items)); }
|
|
|
|
// Function implementations for IfcRepresentationContext
|
|
std::optional< std::string > Ifc4::IfcRepresentationContext::ContextIdentifier() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcRepresentationContext::setContextIdentifier(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< std::string > Ifc4::IfcRepresentationContext::ContextType() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcRepresentationContext::setContextType(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
|
|
std::vector<::Ifc4::IfcRepresentation> Ifc4::IfcRepresentationContext::RepresentationsInContext() const { return cast_vector<IfcRepresentation>(file()->getInverse(data()->id(), IFC4_types[846], 0)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcRepresentationContext::Class() { return *((IfcParse::entity*)IFC4_types[847]); }
|
|
void Ifc4::IfcRepresentationContext::initialize(std::optional< std::string > v1_ContextIdentifier, std::optional< std::string > v2_ContextType) { if (v1_ContextIdentifier) {set_attribute_value(0, (*v1_ContextIdentifier)); } if (v2_ContextType) {set_attribute_value(1, (*v2_ContextType)); } }
|
|
|
|
// Function implementations for IfcRepresentationItem
|
|
|
|
std::vector<::Ifc4::IfcPresentationLayerAssignment> Ifc4::IfcRepresentationItem::LayerAssignment() const { return cast_vector<IfcPresentationLayerAssignment>(file()->getInverse(data()->id(), IFC4_types[699], 2)); }
|
|
std::vector<::Ifc4::IfcStyledItem> Ifc4::IfcRepresentationItem::StyledByItem() const { return cast_vector<IfcStyledItem>(file()->getInverse(data()->id(), IFC4_types[994], 0)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcRepresentationItem::Class() { return *((IfcParse::entity*)IFC4_types[848]); }
|
|
void Ifc4::IfcRepresentationItem::initialize() { }
|
|
|
|
// Function implementations for IfcRepresentationMap
|
|
::Ifc4::IfcAxis2Placement Ifc4::IfcRepresentationMap::MappingOrigin() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcAxis2Placement>(); }
|
|
void Ifc4::IfcRepresentationMap::setMappingOrigin(const ::Ifc4::IfcAxis2Placement& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcRepresentation Ifc4::IfcRepresentationMap::MappedRepresentation() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcRepresentation>(); }
|
|
void Ifc4::IfcRepresentationMap::setMappedRepresentation(const ::Ifc4::IfcRepresentation& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
std::vector<::Ifc4::IfcShapeAspect> Ifc4::IfcRepresentationMap::HasShapeAspects() const { return cast_vector<IfcShapeAspect>(file()->getInverse(data()->id(), IFC4_types[890], 4)); }
|
|
std::vector<::Ifc4::IfcMappedItem> Ifc4::IfcRepresentationMap::MapUsage() const { return cast_vector<IfcMappedItem>(file()->getInverse(data()->id(), IFC4_types[553], 0)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcRepresentationMap::Class() { return *((IfcParse::entity*)IFC4_types[849]); }
|
|
void Ifc4::IfcRepresentationMap::initialize(::Ifc4::IfcAxis2Placement v1_MappingOrigin, ::Ifc4::IfcRepresentation v2_MappedRepresentation) { set_attribute_value(0, (v1_MappingOrigin));set_attribute_value(1, (v2_MappedRepresentation)); }
|
|
|
|
// Function implementations for IfcResource
|
|
std::optional< std::string > Ifc4::IfcResource::Identification() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcResource::setIdentification(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< std::string > Ifc4::IfcResource::LongDescription() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcResource::setLongDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
|
|
std::vector<::Ifc4::IfcRelAssignsToResource> Ifc4::IfcResource::ResourceOf() const { return cast_vector<IfcRelAssignsToResource>(file()->getInverse(data()->id(), IFC4_types[805], 6)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcResource::Class() { return *((IfcParse::entity*)IFC4_types[850]); }
|
|
void Ifc4::IfcResource::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< std::string > v7_LongDescription) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_LongDescription) {set_attribute_value(6, (*v7_LongDescription)); } }
|
|
|
|
// Function implementations for IfcResourceApprovalRelationship
|
|
std::vector< ::Ifc4::IfcResourceObjectSelect > Ifc4::IfcResourceApprovalRelationship::RelatedResourceObjects() const { std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcResourceObjectSelect>(es); }
|
|
void Ifc4::IfcResourceApprovalRelationship::setRelatedResourceObjects(const std::vector< ::Ifc4::IfcResourceObjectSelect >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcApproval Ifc4::IfcResourceApprovalRelationship::RelatingApproval() const { return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcApproval>(); }
|
|
void Ifc4::IfcResourceApprovalRelationship::setRelatingApproval(const ::Ifc4::IfcApproval& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcResourceApprovalRelationship::Class() { return *((IfcParse::entity*)IFC4_types[851]); }
|
|
void Ifc4::IfcResourceApprovalRelationship::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, std::vector< ::Ifc4::IfcResourceObjectSelect > v3_RelatedResourceObjects, ::Ifc4::IfcApproval v4_RelatingApproval) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, cast_vector<express::Base>(v3_RelatedResourceObjects));set_attribute_value(3, (v4_RelatingApproval)); }
|
|
|
|
// Function implementations for IfcResourceConstraintRelationship
|
|
::Ifc4::IfcConstraint Ifc4::IfcResourceConstraintRelationship::RelatingConstraint() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcConstraint>(); }
|
|
void Ifc4::IfcResourceConstraintRelationship::setRelatingConstraint(const ::Ifc4::IfcConstraint& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
std::vector< ::Ifc4::IfcResourceObjectSelect > Ifc4::IfcResourceConstraintRelationship::RelatedResourceObjects() const { std::vector<express::Base> es = get_attribute_value(3); return cast_vector<::Ifc4::IfcResourceObjectSelect>(es); }
|
|
void Ifc4::IfcResourceConstraintRelationship::setRelatedResourceObjects(const std::vector< ::Ifc4::IfcResourceObjectSelect >& v) { set_attribute_value(3, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcResourceConstraintRelationship::Class() { return *((IfcParse::entity*)IFC4_types[852]); }
|
|
void Ifc4::IfcResourceConstraintRelationship::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description, ::Ifc4::IfcConstraint v3_RelatingConstraint, std::vector< ::Ifc4::IfcResourceObjectSelect > v4_RelatedResourceObjects) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_RelatingConstraint));set_attribute_value(3, cast_vector<express::Base>(v4_RelatedResourceObjects)); }
|
|
|
|
// Function implementations for IfcResourceLevelRelationship
|
|
std::optional< std::string > Ifc4::IfcResourceLevelRelationship::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcResourceLevelRelationship::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< std::string > Ifc4::IfcResourceLevelRelationship::Description() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcResourceLevelRelationship::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcResourceLevelRelationship::Class() { return *((IfcParse::entity*)IFC4_types[853]); }
|
|
void Ifc4::IfcResourceLevelRelationship::initialize(std::optional< std::string > v1_Name, std::optional< std::string > v2_Description) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Description) {set_attribute_value(1, (*v2_Description)); } }
|
|
|
|
// Function implementations for IfcResourceTime
|
|
std::optional< std::string > Ifc4::IfcResourceTime::ScheduleWork() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcResourceTime::setScheduleWork(const std::optional< std::string >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< double > Ifc4::IfcResourceTime::ScheduleUsage() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcResourceTime::setScheduleUsage(const std::optional< double >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcResourceTime::ScheduleStart() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcResourceTime::setScheduleStart(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< std::string > Ifc4::IfcResourceTime::ScheduleFinish() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcResourceTime::setScheduleFinish(const std::optional< std::string >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
std::optional< std::string > Ifc4::IfcResourceTime::ScheduleContour() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::string v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcResourceTime::setScheduleContour(const std::optional< std::string >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< std::string > Ifc4::IfcResourceTime::LevelingDelay() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcResourceTime::setLevelingDelay(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
std::optional< bool > Ifc4::IfcResourceTime::IsOverAllocated() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } bool v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcResourceTime::setIsOverAllocated(const std::optional< bool >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
std::optional< std::string > Ifc4::IfcResourceTime::StatusTime() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } std::string v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcResourceTime::setStatusTime(const std::optional< std::string >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::optional< std::string > Ifc4::IfcResourceTime::ActualWork() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } std::string v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcResourceTime::setActualWork(const std::optional< std::string >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
std::optional< double > Ifc4::IfcResourceTime::ActualUsage() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } double v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcResourceTime::setActualUsage(const std::optional< double >& v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
|
|
std::optional< std::string > Ifc4::IfcResourceTime::ActualStart() const { if(get_attribute_value(13).isNull()) { return std::nullopt; } std::string v = get_attribute_value(13); return v; }
|
|
void Ifc4::IfcResourceTime::setActualStart(const std::optional< std::string >& v) { if (v) {set_attribute_value(13, *v);} else {unset_attribute_value(13);} }
|
|
std::optional< std::string > Ifc4::IfcResourceTime::ActualFinish() const { if(get_attribute_value(14).isNull()) { return std::nullopt; } std::string v = get_attribute_value(14); return v; }
|
|
void Ifc4::IfcResourceTime::setActualFinish(const std::optional< std::string >& v) { if (v) {set_attribute_value(14, *v);} else {unset_attribute_value(14);} }
|
|
std::optional< std::string > Ifc4::IfcResourceTime::RemainingWork() const { if(get_attribute_value(15).isNull()) { return std::nullopt; } std::string v = get_attribute_value(15); return v; }
|
|
void Ifc4::IfcResourceTime::setRemainingWork(const std::optional< std::string >& v) { if (v) {set_attribute_value(15, *v);} else {unset_attribute_value(15);} }
|
|
std::optional< double > Ifc4::IfcResourceTime::RemainingUsage() const { if(get_attribute_value(16).isNull()) { return std::nullopt; } double v = get_attribute_value(16); return v; }
|
|
void Ifc4::IfcResourceTime::setRemainingUsage(const std::optional< double >& v) { if (v) {set_attribute_value(16, *v);} else {unset_attribute_value(16);} }
|
|
std::optional< double > Ifc4::IfcResourceTime::Completion() const { if(get_attribute_value(17).isNull()) { return std::nullopt; } double v = get_attribute_value(17); return v; }
|
|
void Ifc4::IfcResourceTime::setCompletion(const std::optional< double >& v) { if (v) {set_attribute_value(17, *v);} else {unset_attribute_value(17);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcResourceTime::Class() { return *((IfcParse::entity*)IFC4_types[856]); }
|
|
void Ifc4::IfcResourceTime::initialize(std::optional< std::string > v1_Name, std::optional< ::Ifc4::IfcDataOriginEnum::Value > v2_DataOrigin, std::optional< std::string > v3_UserDefinedDataOrigin, std::optional< std::string > v4_ScheduleWork, std::optional< double > v5_ScheduleUsage, std::optional< std::string > v6_ScheduleStart, std::optional< std::string > v7_ScheduleFinish, std::optional< std::string > v8_ScheduleContour, std::optional< std::string > v9_LevelingDelay, std::optional< bool > v10_IsOverAllocated, std::optional< std::string > v11_StatusTime, std::optional< std::string > v12_ActualWork, std::optional< double > v13_ActualUsage, std::optional< std::string > v14_ActualStart, std::optional< std::string > v15_ActualFinish, std::optional< std::string > v16_RemainingWork, std::optional< double > v17_RemainingUsage, std::optional< double > v18_Completion) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_DataOrigin) {set_attribute_value(1, (EnumerationReference(&::Ifc4::IfcDataOriginEnum::Class(),(size_t)*v2_DataOrigin))); } if (v3_UserDefinedDataOrigin) {set_attribute_value(2, (*v3_UserDefinedDataOrigin)); } if (v4_ScheduleWork) {set_attribute_value(3, (*v4_ScheduleWork)); } if (v5_ScheduleUsage) {set_attribute_value(4, (*v5_ScheduleUsage)); } if (v6_ScheduleStart) {set_attribute_value(5, (*v6_ScheduleStart)); } if (v7_ScheduleFinish) {set_attribute_value(6, (*v7_ScheduleFinish)); } if (v8_ScheduleContour) {set_attribute_value(7, (*v8_ScheduleContour)); } if (v9_LevelingDelay) {set_attribute_value(8, (*v9_LevelingDelay)); } if (v10_IsOverAllocated) {set_attribute_value(9, (*v10_IsOverAllocated)); } if (v11_StatusTime) {set_attribute_value(10, (*v11_StatusTime)); } if (v12_ActualWork) {set_attribute_value(11, (*v12_ActualWork)); } if (v13_ActualUsage) {set_attribute_value(12, (*v13_ActualUsage)); } if (v14_ActualStart) {set_attribute_value(13, (*v14_ActualStart)); } if (v15_ActualFinish) {set_attribute_value(14, (*v15_ActualFinish)); } if (v16_RemainingWork) {set_attribute_value(15, (*v16_RemainingWork)); } if (v17_RemainingUsage) {set_attribute_value(16, (*v17_RemainingUsage)); } if (v18_Completion) {set_attribute_value(17, (*v18_Completion)); } }
|
|
|
|
// Function implementations for IfcRevolvedAreaSolid
|
|
::Ifc4::IfcAxis1Placement Ifc4::IfcRevolvedAreaSolid::Axis() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcAxis1Placement>(); }
|
|
void Ifc4::IfcRevolvedAreaSolid::setAxis(const ::Ifc4::IfcAxis1Placement& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
double Ifc4::IfcRevolvedAreaSolid::Angle() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcRevolvedAreaSolid::setAngle(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRevolvedAreaSolid::Class() { return *((IfcParse::entity*)IFC4_types[857]); }
|
|
void Ifc4::IfcRevolvedAreaSolid::initialize(::Ifc4::IfcProfileDef v1_SweptArea, ::Ifc4::IfcAxis2Placement3D v2_Position, ::Ifc4::IfcAxis1Placement v3_Axis, double v4_Angle) { set_attribute_value(0, (v1_SweptArea));set_attribute_value(1, (v2_Position));set_attribute_value(2, (v3_Axis));set_attribute_value(3, (v4_Angle)); }
|
|
|
|
// Function implementations for IfcRevolvedAreaSolidTapered
|
|
::Ifc4::IfcProfileDef Ifc4::IfcRevolvedAreaSolidTapered::EndSweptArea() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcProfileDef>(); }
|
|
void Ifc4::IfcRevolvedAreaSolidTapered::setEndSweptArea(const ::Ifc4::IfcProfileDef& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRevolvedAreaSolidTapered::Class() { return *((IfcParse::entity*)IFC4_types[858]); }
|
|
void Ifc4::IfcRevolvedAreaSolidTapered::initialize(::Ifc4::IfcProfileDef v1_SweptArea, ::Ifc4::IfcAxis2Placement3D v2_Position, ::Ifc4::IfcAxis1Placement v3_Axis, double v4_Angle, ::Ifc4::IfcProfileDef v5_EndSweptArea) { set_attribute_value(0, (v1_SweptArea));set_attribute_value(1, (v2_Position));set_attribute_value(2, (v3_Axis));set_attribute_value(3, (v4_Angle));set_attribute_value(4, (v5_EndSweptArea)); }
|
|
|
|
// Function implementations for IfcRightCircularCone
|
|
double Ifc4::IfcRightCircularCone::Height() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcRightCircularCone::setHeight(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
double Ifc4::IfcRightCircularCone::BottomRadius() const { double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcRightCircularCone::setBottomRadius(const double& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRightCircularCone::Class() { return *((IfcParse::entity*)IFC4_types[859]); }
|
|
void Ifc4::IfcRightCircularCone::initialize(::Ifc4::IfcAxis2Placement3D v1_Position, double v2_Height, double v3_BottomRadius) { set_attribute_value(0, (v1_Position));set_attribute_value(1, (v2_Height));set_attribute_value(2, (v3_BottomRadius)); }
|
|
|
|
// Function implementations for IfcRightCircularCylinder
|
|
double Ifc4::IfcRightCircularCylinder::Height() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcRightCircularCylinder::setHeight(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
double Ifc4::IfcRightCircularCylinder::Radius() const { double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcRightCircularCylinder::setRadius(const double& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRightCircularCylinder::Class() { return *((IfcParse::entity*)IFC4_types[860]); }
|
|
void Ifc4::IfcRightCircularCylinder::initialize(::Ifc4::IfcAxis2Placement3D v1_Position, double v2_Height, double v3_Radius) { set_attribute_value(0, (v1_Position));set_attribute_value(1, (v2_Height));set_attribute_value(2, (v3_Radius)); }
|
|
|
|
// Function implementations for IfcRoof
|
|
std::optional< ::Ifc4::IfcRoofTypeEnum::Value > Ifc4::IfcRoof::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcRoofTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcRoof::setPredefinedType(const std::optional< ::Ifc4::IfcRoofTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcRoofTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRoof::Class() { return *((IfcParse::entity*)IFC4_types[862]); }
|
|
void Ifc4::IfcRoof::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcRoofTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcRoofTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcRoofType
|
|
::Ifc4::IfcRoofTypeEnum::Value Ifc4::IfcRoofType::PredefinedType() const { return ::Ifc4::IfcRoofTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcRoofType::setPredefinedType(const ::Ifc4::IfcRoofTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcRoofTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRoofType::Class() { return *((IfcParse::entity*)IFC4_types[863]); }
|
|
void Ifc4::IfcRoofType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcRoofTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcRoofTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcRoot
|
|
std::string Ifc4::IfcRoot::GlobalId() const { std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcRoot::setGlobalId(const std::string& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcOwnerHistory Ifc4::IfcRoot::OwnerHistory() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcOwnerHistory{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcOwnerHistory>(); }
|
|
void Ifc4::IfcRoot::setOwnerHistory(const ::Ifc4::IfcOwnerHistory& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
std::optional< std::string > Ifc4::IfcRoot::Name() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcRoot::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< std::string > Ifc4::IfcRoot::Description() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcRoot::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRoot::Class() { return *((IfcParse::entity*)IFC4_types[865]); }
|
|
void Ifc4::IfcRoot::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } }
|
|
|
|
// Function implementations for IfcRoundedRectangleProfileDef
|
|
double Ifc4::IfcRoundedRectangleProfileDef::RoundingRadius() const { double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcRoundedRectangleProfileDef::setRoundingRadius(const double& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcRoundedRectangleProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[870]); }
|
|
void Ifc4::IfcRoundedRectangleProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcAxis2Placement2D v3_Position, double v4_XDim, double v5_YDim, double v6_RoundingRadius) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Position));set_attribute_value(3, (v4_XDim));set_attribute_value(4, (v5_YDim));set_attribute_value(5, (v6_RoundingRadius)); }
|
|
|
|
// Function implementations for IfcSIUnit
|
|
std::optional< ::Ifc4::IfcSIPrefix::Value > Ifc4::IfcSIUnit::Prefix() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } return ::Ifc4::IfcSIPrefix::FromString(get_attribute_value(2)); }
|
|
void Ifc4::IfcSIUnit::setPrefix(const std::optional< ::Ifc4::IfcSIPrefix::Value >& v) { if (v) {set_attribute_value(2, EnumerationReference(&::Ifc4::IfcSIPrefix::Class(), (size_t) *v));} else {unset_attribute_value(2);} }
|
|
::Ifc4::IfcSIUnitName::Value Ifc4::IfcSIUnit::Name() const { return ::Ifc4::IfcSIUnitName::FromString(get_attribute_value(3)); }
|
|
void Ifc4::IfcSIUnit::setName(const ::Ifc4::IfcSIUnitName::Value& v) { set_attribute_value(3, EnumerationReference(&::Ifc4::IfcSIUnitName::Class(), (size_t) v));if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSIUnit::Class() { return *((IfcParse::entity*)IFC4_types[902]); }
|
|
void Ifc4::IfcSIUnit::initialize(::Ifc4::IfcUnitEnum::Value v2_UnitType, std::optional< ::Ifc4::IfcSIPrefix::Value > v3_Prefix, ::Ifc4::IfcSIUnitName::Value v4_Name) { set_attribute_value(1, (EnumerationReference(&::Ifc4::IfcUnitEnum::Class(),(size_t)v2_UnitType))); if (v3_Prefix) {set_attribute_value(2, (EnumerationReference(&::Ifc4::IfcSIPrefix::Class(),(size_t)*v3_Prefix))); }set_attribute_value(3, (EnumerationReference(&::Ifc4::IfcSIUnitName::Class(),(size_t)v4_Name))); }
|
|
|
|
// Function implementations for IfcSanitaryTerminal
|
|
std::optional< ::Ifc4::IfcSanitaryTerminalTypeEnum::Value > Ifc4::IfcSanitaryTerminal::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcSanitaryTerminalTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcSanitaryTerminal::setPredefinedType(const std::optional< ::Ifc4::IfcSanitaryTerminalTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcSanitaryTerminalTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSanitaryTerminal::Class() { return *((IfcParse::entity*)IFC4_types[871]); }
|
|
void Ifc4::IfcSanitaryTerminal::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcSanitaryTerminalTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcSanitaryTerminalTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcSanitaryTerminalType
|
|
::Ifc4::IfcSanitaryTerminalTypeEnum::Value Ifc4::IfcSanitaryTerminalType::PredefinedType() const { return ::Ifc4::IfcSanitaryTerminalTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcSanitaryTerminalType::setPredefinedType(const ::Ifc4::IfcSanitaryTerminalTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcSanitaryTerminalTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSanitaryTerminalType::Class() { return *((IfcParse::entity*)IFC4_types[872]); }
|
|
void Ifc4::IfcSanitaryTerminalType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcSanitaryTerminalTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcSanitaryTerminalTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcSchedulingTime
|
|
std::optional< std::string > Ifc4::IfcSchedulingTime::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcSchedulingTime::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< ::Ifc4::IfcDataOriginEnum::Value > Ifc4::IfcSchedulingTime::DataOrigin() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } return ::Ifc4::IfcDataOriginEnum::FromString(get_attribute_value(1)); }
|
|
void Ifc4::IfcSchedulingTime::setDataOrigin(const std::optional< ::Ifc4::IfcDataOriginEnum::Value >& v) { if (v) {set_attribute_value(1, EnumerationReference(&::Ifc4::IfcDataOriginEnum::Class(), (size_t) *v));} else {unset_attribute_value(1);} }
|
|
std::optional< std::string > Ifc4::IfcSchedulingTime::UserDefinedDataOrigin() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcSchedulingTime::setUserDefinedDataOrigin(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSchedulingTime::Class() { return *((IfcParse::entity*)IFC4_types[874]); }
|
|
void Ifc4::IfcSchedulingTime::initialize(std::optional< std::string > v1_Name, std::optional< ::Ifc4::IfcDataOriginEnum::Value > v2_DataOrigin, std::optional< std::string > v3_UserDefinedDataOrigin) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_DataOrigin) {set_attribute_value(1, (EnumerationReference(&::Ifc4::IfcDataOriginEnum::Class(),(size_t)*v2_DataOrigin))); } if (v3_UserDefinedDataOrigin) {set_attribute_value(2, (*v3_UserDefinedDataOrigin)); } }
|
|
|
|
// Function implementations for IfcSeamCurve
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSeamCurve::Class() { return *((IfcParse::entity*)IFC4_types[875]); }
|
|
void Ifc4::IfcSeamCurve::initialize(::Ifc4::IfcCurve v1_Curve3D, std::vector< ::Ifc4::IfcPcurve > v2_AssociatedGeometry, ::Ifc4::IfcPreferredSurfaceCurveRepresentation::Value v3_MasterRepresentation) { set_attribute_value(0, (v1_Curve3D));set_attribute_value(1, cast_vector<express::Base>(v2_AssociatedGeometry));set_attribute_value(2, (EnumerationReference(&::Ifc4::IfcPreferredSurfaceCurveRepresentation::Class(),(size_t)v3_MasterRepresentation))); }
|
|
|
|
// Function implementations for IfcSectionProperties
|
|
::Ifc4::IfcSectionTypeEnum::Value Ifc4::IfcSectionProperties::SectionType() const { return ::Ifc4::IfcSectionTypeEnum::FromString(get_attribute_value(0)); }
|
|
void Ifc4::IfcSectionProperties::setSectionType(const ::Ifc4::IfcSectionTypeEnum::Value& v) { set_attribute_value(0, EnumerationReference(&::Ifc4::IfcSectionTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcProfileDef Ifc4::IfcSectionProperties::StartProfile() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcProfileDef>(); }
|
|
void Ifc4::IfcSectionProperties::setStartProfile(const ::Ifc4::IfcProfileDef& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcProfileDef Ifc4::IfcSectionProperties::EndProfile() const { if(get_attribute_value(2).isNull()) { return ::Ifc4::IfcProfileDef{}; } return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcProfileDef>(); }
|
|
void Ifc4::IfcSectionProperties::setEndProfile(const ::Ifc4::IfcProfileDef& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSectionProperties::Class() { return *((IfcParse::entity*)IFC4_types[879]); }
|
|
void Ifc4::IfcSectionProperties::initialize(::Ifc4::IfcSectionTypeEnum::Value v1_SectionType, ::Ifc4::IfcProfileDef v2_StartProfile, ::Ifc4::IfcProfileDef v3_EndProfile) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcSectionTypeEnum::Class(),(size_t)v1_SectionType)));set_attribute_value(1, (v2_StartProfile));set_attribute_value(2, (v3_EndProfile)); }
|
|
|
|
// Function implementations for IfcSectionReinforcementProperties
|
|
double Ifc4::IfcSectionReinforcementProperties::LongitudinalStartPosition() const { double v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcSectionReinforcementProperties::setLongitudinalStartPosition(const double& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
double Ifc4::IfcSectionReinforcementProperties::LongitudinalEndPosition() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcSectionReinforcementProperties::setLongitudinalEndPosition(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
std::optional< double > Ifc4::IfcSectionReinforcementProperties::TransversePosition() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcSectionReinforcementProperties::setTransversePosition(const std::optional< double >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
::Ifc4::IfcReinforcingBarRoleEnum::Value Ifc4::IfcSectionReinforcementProperties::ReinforcementRole() const { return ::Ifc4::IfcReinforcingBarRoleEnum::FromString(get_attribute_value(3)); }
|
|
void Ifc4::IfcSectionReinforcementProperties::setReinforcementRole(const ::Ifc4::IfcReinforcingBarRoleEnum::Value& v) { set_attribute_value(3, EnumerationReference(&::Ifc4::IfcReinforcingBarRoleEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(3); }
|
|
::Ifc4::IfcSectionProperties Ifc4::IfcSectionReinforcementProperties::SectionDefinition() const { return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcSectionProperties>(); }
|
|
void Ifc4::IfcSectionReinforcementProperties::setSectionDefinition(const ::Ifc4::IfcSectionProperties& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
std::vector< ::Ifc4::IfcReinforcementBarProperties > Ifc4::IfcSectionReinforcementProperties::CrossSectionReinforcementDefinitions() const { std::vector<express::Base> es = get_attribute_value(5); return cast_vector<::Ifc4::IfcReinforcementBarProperties>(es); }
|
|
void Ifc4::IfcSectionReinforcementProperties::setCrossSectionReinforcementDefinitions(const std::vector< ::Ifc4::IfcReinforcementBarProperties >& v) { set_attribute_value(5, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSectionReinforcementProperties::Class() { return *((IfcParse::entity*)IFC4_types[880]); }
|
|
void Ifc4::IfcSectionReinforcementProperties::initialize(double v1_LongitudinalStartPosition, double v2_LongitudinalEndPosition, std::optional< double > v3_TransversePosition, ::Ifc4::IfcReinforcingBarRoleEnum::Value v4_ReinforcementRole, ::Ifc4::IfcSectionProperties v5_SectionDefinition, std::vector< ::Ifc4::IfcReinforcementBarProperties > v6_CrossSectionReinforcementDefinitions) { 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(&::Ifc4::IfcReinforcingBarRoleEnum::Class(),(size_t)v4_ReinforcementRole)));set_attribute_value(4, (v5_SectionDefinition));set_attribute_value(5, cast_vector<express::Base>(v6_CrossSectionReinforcementDefinitions)); }
|
|
|
|
// Function implementations for IfcSectionedSpine
|
|
::Ifc4::IfcCompositeCurve Ifc4::IfcSectionedSpine::SpineCurve() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcCompositeCurve>(); }
|
|
void Ifc4::IfcSectionedSpine::setSpineCurve(const ::Ifc4::IfcCompositeCurve& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::vector< ::Ifc4::IfcProfileDef > Ifc4::IfcSectionedSpine::CrossSections() const { std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcProfileDef>(es); }
|
|
void Ifc4::IfcSectionedSpine::setCrossSections(const std::vector< ::Ifc4::IfcProfileDef >& v) { set_attribute_value(1, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(1); }
|
|
std::vector< ::Ifc4::IfcAxis2Placement3D > Ifc4::IfcSectionedSpine::CrossSectionPositions() const { std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcAxis2Placement3D>(es); }
|
|
void Ifc4::IfcSectionedSpine::setCrossSectionPositions(const std::vector< ::Ifc4::IfcAxis2Placement3D >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSectionedSpine::Class() { return *((IfcParse::entity*)IFC4_types[877]); }
|
|
void Ifc4::IfcSectionedSpine::initialize(::Ifc4::IfcCompositeCurve v1_SpineCurve, std::vector< ::Ifc4::IfcProfileDef > v2_CrossSections, std::vector< ::Ifc4::IfcAxis2Placement3D > v3_CrossSectionPositions) { set_attribute_value(0, (v1_SpineCurve));set_attribute_value(1, cast_vector<express::Base>(v2_CrossSections));set_attribute_value(2, cast_vector<express::Base>(v3_CrossSectionPositions)); }
|
|
|
|
// Function implementations for IfcSensor
|
|
std::optional< ::Ifc4::IfcSensorTypeEnum::Value > Ifc4::IfcSensor::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcSensorTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcSensor::setPredefinedType(const std::optional< ::Ifc4::IfcSensorTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcSensorTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSensor::Class() { return *((IfcParse::entity*)IFC4_types[883]); }
|
|
void Ifc4::IfcSensor::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcSensorTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcSensorTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcSensorType
|
|
::Ifc4::IfcSensorTypeEnum::Value Ifc4::IfcSensorType::PredefinedType() const { return ::Ifc4::IfcSensorTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcSensorType::setPredefinedType(const ::Ifc4::IfcSensorTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcSensorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSensorType::Class() { return *((IfcParse::entity*)IFC4_types[884]); }
|
|
void Ifc4::IfcSensorType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcSensorTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcSensorTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcShadingDevice
|
|
std::optional< ::Ifc4::IfcShadingDeviceTypeEnum::Value > Ifc4::IfcShadingDevice::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcShadingDeviceTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcShadingDevice::setPredefinedType(const std::optional< ::Ifc4::IfcShadingDeviceTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcShadingDeviceTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcShadingDevice::Class() { return *((IfcParse::entity*)IFC4_types[887]); }
|
|
void Ifc4::IfcShadingDevice::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcShadingDeviceTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcShadingDeviceTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcShadingDeviceType
|
|
::Ifc4::IfcShadingDeviceTypeEnum::Value Ifc4::IfcShadingDeviceType::PredefinedType() const { return ::Ifc4::IfcShadingDeviceTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcShadingDeviceType::setPredefinedType(const ::Ifc4::IfcShadingDeviceTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcShadingDeviceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcShadingDeviceType::Class() { return *((IfcParse::entity*)IFC4_types[888]); }
|
|
void Ifc4::IfcShadingDeviceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcShadingDeviceTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcShadingDeviceTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcShapeAspect
|
|
std::vector< ::Ifc4::IfcShapeModel > Ifc4::IfcShapeAspect::ShapeRepresentations() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcShapeModel>(es); }
|
|
void Ifc4::IfcShapeAspect::setShapeRepresentations(const std::vector< ::Ifc4::IfcShapeModel >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< std::string > Ifc4::IfcShapeAspect::Name() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcShapeAspect::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< std::string > Ifc4::IfcShapeAspect::Description() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcShapeAspect::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
boost::logic::tribool Ifc4::IfcShapeAspect::ProductDefinitional() const { boost::logic::tribool v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcShapeAspect::setProductDefinitional(const boost::logic::tribool& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
::Ifc4::IfcProductRepresentationSelect Ifc4::IfcShapeAspect::PartOfProductDefinitionShape() const { if(get_attribute_value(4).isNull()) { return ::Ifc4::IfcProductRepresentationSelect{}; } return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcProductRepresentationSelect>(); }
|
|
void Ifc4::IfcShapeAspect::setPartOfProductDefinitionShape(const ::Ifc4::IfcProductRepresentationSelect& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcShapeAspect::Class() { return *((IfcParse::entity*)IFC4_types[890]); }
|
|
void Ifc4::IfcShapeAspect::initialize(std::vector< ::Ifc4::IfcShapeModel > v1_ShapeRepresentations, std::optional< std::string > v2_Name, std::optional< std::string > v3_Description, boost::logic::tribool v4_ProductDefinitional, ::Ifc4::IfcProductRepresentationSelect v5_PartOfProductDefinitionShape) { set_attribute_value(0, cast_vector<express::Base>(v1_ShapeRepresentations)); 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)); }
|
|
|
|
// Function implementations for IfcShapeModel
|
|
|
|
std::vector<::Ifc4::IfcShapeAspect> Ifc4::IfcShapeModel::OfShapeAspect() const { return cast_vector<IfcShapeAspect>(file()->getInverse(data()->id(), IFC4_types[890], 0)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcShapeModel::Class() { return *((IfcParse::entity*)IFC4_types[891]); }
|
|
void Ifc4::IfcShapeModel::initialize(::Ifc4::IfcRepresentationContext v1_ContextOfItems, std::optional< std::string > v2_RepresentationIdentifier, std::optional< std::string > v3_RepresentationType, std::vector< ::Ifc4::IfcRepresentationItem > v4_Items) { set_attribute_value(0, (v1_ContextOfItems)); if (v2_RepresentationIdentifier) {set_attribute_value(1, (*v2_RepresentationIdentifier)); } if (v3_RepresentationType) {set_attribute_value(2, (*v3_RepresentationType)); }set_attribute_value(3, cast_vector<express::Base>(v4_Items)); }
|
|
|
|
// Function implementations for IfcShapeRepresentation
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcShapeRepresentation::Class() { return *((IfcParse::entity*)IFC4_types[892]); }
|
|
void Ifc4::IfcShapeRepresentation::initialize(::Ifc4::IfcRepresentationContext v1_ContextOfItems, std::optional< std::string > v2_RepresentationIdentifier, std::optional< std::string > v3_RepresentationType, std::vector< ::Ifc4::IfcRepresentationItem > v4_Items) { set_attribute_value(0, (v1_ContextOfItems)); if (v2_RepresentationIdentifier) {set_attribute_value(1, (*v2_RepresentationIdentifier)); } if (v3_RepresentationType) {set_attribute_value(2, (*v3_RepresentationType)); }set_attribute_value(3, cast_vector<express::Base>(v4_Items)); }
|
|
|
|
// Function implementations for IfcShellBasedSurfaceModel
|
|
std::vector< ::Ifc4::IfcShell > Ifc4::IfcShellBasedSurfaceModel::SbsmBoundary() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcShell>(es); }
|
|
void Ifc4::IfcShellBasedSurfaceModel::setSbsmBoundary(const std::vector< ::Ifc4::IfcShell >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcShellBasedSurfaceModel::Class() { return *((IfcParse::entity*)IFC4_types[895]); }
|
|
void Ifc4::IfcShellBasedSurfaceModel::initialize(std::vector< ::Ifc4::IfcShell > v1_SbsmBoundary) { set_attribute_value(0, cast_vector<express::Base>(v1_SbsmBoundary)); }
|
|
|
|
// Function implementations for IfcSimpleProperty
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSimpleProperty::Class() { return *((IfcParse::entity*)IFC4_types[896]); }
|
|
void Ifc4::IfcSimpleProperty::initialize(std::string v1_Name, std::optional< std::string > v2_Description) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); } }
|
|
|
|
// Function implementations for IfcSimplePropertyTemplate
|
|
std::optional< ::Ifc4::IfcSimplePropertyTemplateTypeEnum::Value > Ifc4::IfcSimplePropertyTemplate::TemplateType() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } return ::Ifc4::IfcSimplePropertyTemplateTypeEnum::FromString(get_attribute_value(4)); }
|
|
void Ifc4::IfcSimplePropertyTemplate::setTemplateType(const std::optional< ::Ifc4::IfcSimplePropertyTemplateTypeEnum::Value >& v) { if (v) {set_attribute_value(4, EnumerationReference(&::Ifc4::IfcSimplePropertyTemplateTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcSimplePropertyTemplate::PrimaryMeasureType() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcSimplePropertyTemplate::setPrimaryMeasureType(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< std::string > Ifc4::IfcSimplePropertyTemplate::SecondaryMeasureType() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcSimplePropertyTemplate::setSecondaryMeasureType(const std::optional< std::string >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
::Ifc4::IfcPropertyEnumeration Ifc4::IfcSimplePropertyTemplate::Enumerators() const { if(get_attribute_value(7).isNull()) { return ::Ifc4::IfcPropertyEnumeration{}; } return ((express::Base)(get_attribute_value(7))).as<::Ifc4::IfcPropertyEnumeration>(); }
|
|
void Ifc4::IfcSimplePropertyTemplate::setEnumerators(const ::Ifc4::IfcPropertyEnumeration& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
::Ifc4::IfcUnit Ifc4::IfcSimplePropertyTemplate::PrimaryUnit() const { if(get_attribute_value(8).isNull()) { return ::Ifc4::IfcUnit{}; } return ((express::Base)(get_attribute_value(8))).as<::Ifc4::IfcUnit>(); }
|
|
void Ifc4::IfcSimplePropertyTemplate::setPrimaryUnit(const ::Ifc4::IfcUnit& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
::Ifc4::IfcUnit Ifc4::IfcSimplePropertyTemplate::SecondaryUnit() const { if(get_attribute_value(9).isNull()) { return ::Ifc4::IfcUnit{}; } return ((express::Base)(get_attribute_value(9))).as<::Ifc4::IfcUnit>(); }
|
|
void Ifc4::IfcSimplePropertyTemplate::setSecondaryUnit(const ::Ifc4::IfcUnit& v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }
|
|
std::optional< std::string > Ifc4::IfcSimplePropertyTemplate::Expression() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } std::string v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcSimplePropertyTemplate::setExpression(const std::optional< std::string >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::optional< ::Ifc4::IfcStateEnum::Value > Ifc4::IfcSimplePropertyTemplate::AccessState() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } return ::Ifc4::IfcStateEnum::FromString(get_attribute_value(11)); }
|
|
void Ifc4::IfcSimplePropertyTemplate::setAccessState(const std::optional< ::Ifc4::IfcStateEnum::Value >& v) { if (v) {set_attribute_value(11, EnumerationReference(&::Ifc4::IfcStateEnum::Class(), (size_t) *v));} else {unset_attribute_value(11);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSimplePropertyTemplate::Class() { return *((IfcParse::entity*)IFC4_types[897]); }
|
|
void Ifc4::IfcSimplePropertyTemplate::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< ::Ifc4::IfcSimplePropertyTemplateTypeEnum::Value > v5_TemplateType, std::optional< std::string > v6_PrimaryMeasureType, std::optional< std::string > v7_SecondaryMeasureType, ::Ifc4::IfcPropertyEnumeration v8_Enumerators, ::Ifc4::IfcUnit v9_PrimaryUnit, ::Ifc4::IfcUnit v10_SecondaryUnit, std::optional< std::string > v11_Expression, std::optional< ::Ifc4::IfcStateEnum::Value > v12_AccessState) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); } if (v5_TemplateType) {set_attribute_value(4, (EnumerationReference(&::Ifc4::IfcSimplePropertyTemplateTypeEnum::Class(),(size_t)*v5_TemplateType))); } if (v6_PrimaryMeasureType) {set_attribute_value(5, (*v6_PrimaryMeasureType)); } if (v7_SecondaryMeasureType) {set_attribute_value(6, (*v7_SecondaryMeasureType)); }set_attribute_value(7, (v8_Enumerators));set_attribute_value(8, (v9_PrimaryUnit));set_attribute_value(9, (v10_SecondaryUnit)); if (v11_Expression) {set_attribute_value(10, (*v11_Expression)); } if (v12_AccessState) {set_attribute_value(11, (EnumerationReference(&::Ifc4::IfcStateEnum::Class(),(size_t)*v12_AccessState))); } }
|
|
|
|
// Function implementations for IfcSite
|
|
std::optional< std::vector< int > /*[3:4]*/ > Ifc4::IfcSite::RefLatitude() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } std::vector< int > /*[3:4]*/ v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcSite::setRefLatitude(const std::optional< std::vector< int > /*[3:4]*/ >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
std::optional< std::vector< int > /*[3:4]*/ > Ifc4::IfcSite::RefLongitude() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } std::vector< int > /*[3:4]*/ v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcSite::setRefLongitude(const std::optional< std::vector< int > /*[3:4]*/ >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::optional< double > Ifc4::IfcSite::RefElevation() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } double v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcSite::setRefElevation(const std::optional< double >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
std::optional< std::string > Ifc4::IfcSite::LandTitleNumber() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } std::string v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcSite::setLandTitleNumber(const std::optional< std::string >& v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
|
|
::Ifc4::IfcPostalAddress Ifc4::IfcSite::SiteAddress() const { if(get_attribute_value(13).isNull()) { return ::Ifc4::IfcPostalAddress{}; } return ((express::Base)(get_attribute_value(13))).as<::Ifc4::IfcPostalAddress>(); }
|
|
void Ifc4::IfcSite::setSiteAddress(const ::Ifc4::IfcPostalAddress& v) { set_attribute_value(13, v);if constexpr (false)unset_attribute_value(13); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSite::Class() { return *((IfcParse::entity*)IFC4_types[901]); }
|
|
void Ifc4::IfcSite::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_LongName, std::optional< ::Ifc4::IfcElementCompositionEnum::Value > v9_CompositionType, std::optional< std::vector< int > /*[3:4]*/ > v10_RefLatitude, std::optional< std::vector< int > /*[3:4]*/ > v11_RefLongitude, std::optional< double > v12_RefElevation, std::optional< std::string > v13_LandTitleNumber, ::Ifc4::IfcPostalAddress v14_SiteAddress) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_LongName) {set_attribute_value(7, (*v8_LongName)); } if (v9_CompositionType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::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)); }
|
|
|
|
// Function implementations for IfcSlab
|
|
std::optional< ::Ifc4::IfcSlabTypeEnum::Value > Ifc4::IfcSlab::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcSlabTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcSlab::setPredefinedType(const std::optional< ::Ifc4::IfcSlabTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcSlabTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSlab::Class() { return *((IfcParse::entity*)IFC4_types[905]); }
|
|
void Ifc4::IfcSlab::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcSlabTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcSlabTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcSlabElementedCase
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSlabElementedCase::Class() { return *((IfcParse::entity*)IFC4_types[906]); }
|
|
void Ifc4::IfcSlabElementedCase::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcSlabTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcSlabTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcSlabStandardCase
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSlabStandardCase::Class() { return *((IfcParse::entity*)IFC4_types[907]); }
|
|
void Ifc4::IfcSlabStandardCase::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcSlabTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcSlabTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcSlabType
|
|
::Ifc4::IfcSlabTypeEnum::Value Ifc4::IfcSlabType::PredefinedType() const { return ::Ifc4::IfcSlabTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcSlabType::setPredefinedType(const ::Ifc4::IfcSlabTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcSlabTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSlabType::Class() { return *((IfcParse::entity*)IFC4_types[908]); }
|
|
void Ifc4::IfcSlabType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcSlabTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcSlabTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcSlippageConnectionCondition
|
|
std::optional< double > Ifc4::IfcSlippageConnectionCondition::SlippageX() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcSlippageConnectionCondition::setSlippageX(const std::optional< double >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< double > Ifc4::IfcSlippageConnectionCondition::SlippageY() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcSlippageConnectionCondition::setSlippageY(const std::optional< double >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< double > Ifc4::IfcSlippageConnectionCondition::SlippageZ() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcSlippageConnectionCondition::setSlippageZ(const std::optional< double >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSlippageConnectionCondition::Class() { return *((IfcParse::entity*)IFC4_types[910]); }
|
|
void Ifc4::IfcSlippageConnectionCondition::initialize(std::optional< std::string > v1_Name, std::optional< double > v2_SlippageX, std::optional< double > v3_SlippageY, std::optional< double > v4_SlippageZ) { 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)); } }
|
|
|
|
// Function implementations for IfcSolarDevice
|
|
std::optional< ::Ifc4::IfcSolarDeviceTypeEnum::Value > Ifc4::IfcSolarDevice::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcSolarDeviceTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcSolarDevice::setPredefinedType(const std::optional< ::Ifc4::IfcSolarDeviceTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcSolarDeviceTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSolarDevice::Class() { return *((IfcParse::entity*)IFC4_types[911]); }
|
|
void Ifc4::IfcSolarDevice::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcSolarDeviceTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcSolarDeviceTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcSolarDeviceType
|
|
::Ifc4::IfcSolarDeviceTypeEnum::Value Ifc4::IfcSolarDeviceType::PredefinedType() const { return ::Ifc4::IfcSolarDeviceTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcSolarDeviceType::setPredefinedType(const ::Ifc4::IfcSolarDeviceTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcSolarDeviceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSolarDeviceType::Class() { return *((IfcParse::entity*)IFC4_types[912]); }
|
|
void Ifc4::IfcSolarDeviceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcSolarDeviceTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcSolarDeviceTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcSolidModel
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSolidModel::Class() { return *((IfcParse::entity*)IFC4_types[915]); }
|
|
void Ifc4::IfcSolidModel::initialize() { }
|
|
|
|
// Function implementations for IfcSpace
|
|
std::optional< ::Ifc4::IfcSpaceTypeEnum::Value > Ifc4::IfcSpace::PredefinedType() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } return ::Ifc4::IfcSpaceTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcSpace::setPredefinedType(const std::optional< ::Ifc4::IfcSpaceTypeEnum::Value >& v) { if (v) {set_attribute_value(9, EnumerationReference(&::Ifc4::IfcSpaceTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(9);} }
|
|
std::optional< double > Ifc4::IfcSpace::ElevationWithFlooring() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } double v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcSpace::setElevationWithFlooring(const std::optional< double >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
|
|
std::vector<::Ifc4::IfcRelCoversSpaces> Ifc4::IfcSpace::HasCoverings() const { return cast_vector<IfcRelCoversSpaces>(file()->getInverse(data()->id(), IFC4_types[825], 4)); }
|
|
std::vector<::Ifc4::IfcRelSpaceBoundary> Ifc4::IfcSpace::BoundedBy() const { return cast_vector<IfcRelSpaceBoundary>(file()->getInverse(data()->id(), IFC4_types[841], 4)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcSpace::Class() { return *((IfcParse::entity*)IFC4_types[921]); }
|
|
void Ifc4::IfcSpace::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_LongName, std::optional< ::Ifc4::IfcElementCompositionEnum::Value > v9_CompositionType, std::optional< ::Ifc4::IfcSpaceTypeEnum::Value > v10_PredefinedType, std::optional< double > v11_ElevationWithFlooring) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_LongName) {set_attribute_value(7, (*v8_LongName)); } if (v9_CompositionType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcElementCompositionEnum::Class(),(size_t)*v9_CompositionType))); } if (v10_PredefinedType) {set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcSpaceTypeEnum::Class(),(size_t)*v10_PredefinedType))); } if (v11_ElevationWithFlooring) {set_attribute_value(10, (*v11_ElevationWithFlooring)); } }
|
|
|
|
// Function implementations for IfcSpaceHeater
|
|
std::optional< ::Ifc4::IfcSpaceHeaterTypeEnum::Value > Ifc4::IfcSpaceHeater::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcSpaceHeaterTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcSpaceHeater::setPredefinedType(const std::optional< ::Ifc4::IfcSpaceHeaterTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcSpaceHeaterTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSpaceHeater::Class() { return *((IfcParse::entity*)IFC4_types[923]); }
|
|
void Ifc4::IfcSpaceHeater::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcSpaceHeaterTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcSpaceHeaterTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcSpaceHeaterType
|
|
::Ifc4::IfcSpaceHeaterTypeEnum::Value Ifc4::IfcSpaceHeaterType::PredefinedType() const { return ::Ifc4::IfcSpaceHeaterTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcSpaceHeaterType::setPredefinedType(const ::Ifc4::IfcSpaceHeaterTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcSpaceHeaterTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSpaceHeaterType::Class() { return *((IfcParse::entity*)IFC4_types[924]); }
|
|
void Ifc4::IfcSpaceHeaterType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcSpaceHeaterTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcSpaceHeaterTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcSpaceType
|
|
::Ifc4::IfcSpaceTypeEnum::Value Ifc4::IfcSpaceType::PredefinedType() const { return ::Ifc4::IfcSpaceTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcSpaceType::setPredefinedType(const ::Ifc4::IfcSpaceTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcSpaceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
std::optional< std::string > Ifc4::IfcSpaceType::LongName() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } std::string v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcSpaceType::setLongName(const std::optional< std::string >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSpaceType::Class() { return *((IfcParse::entity*)IFC4_types[926]); }
|
|
void Ifc4::IfcSpaceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcSpaceTypeEnum::Value v10_PredefinedType, std::optional< std::string > v11_LongName) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcSpaceTypeEnum::Class(),(size_t)v10_PredefinedType))); if (v11_LongName) {set_attribute_value(10, (*v11_LongName)); } }
|
|
|
|
// Function implementations for IfcSpatialElement
|
|
std::optional< std::string > Ifc4::IfcSpatialElement::LongName() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::string v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcSpatialElement::setLongName(const std::optional< std::string >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
|
|
std::vector<::Ifc4::IfcRelContainedInSpatialStructure> Ifc4::IfcSpatialElement::ContainsElements() const { return cast_vector<IfcRelContainedInSpatialStructure>(file()->getInverse(data()->id(), IFC4_types[823], 5)); }
|
|
std::vector<::Ifc4::IfcRelServicesBuildings> Ifc4::IfcSpatialElement::ServicedBySystems() const { return cast_vector<IfcRelServicesBuildings>(file()->getInverse(data()->id(), IFC4_types[840], 5)); }
|
|
std::vector<::Ifc4::IfcRelReferencedInSpatialStructure> Ifc4::IfcSpatialElement::ReferencesElements() const { return cast_vector<IfcRelReferencedInSpatialStructure>(file()->getInverse(data()->id(), IFC4_types[838], 5)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcSpatialElement::Class() { return *((IfcParse::entity*)IFC4_types[928]); }
|
|
void Ifc4::IfcSpatialElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_LongName) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_LongName) {set_attribute_value(7, (*v8_LongName)); } }
|
|
|
|
// Function implementations for IfcSpatialElementType
|
|
std::optional< std::string > Ifc4::IfcSpatialElementType::ElementType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcSpatialElementType::setElementType(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSpatialElementType::Class() { return *((IfcParse::entity*)IFC4_types[929]); }
|
|
void Ifc4::IfcSpatialElementType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcSpatialStructureElement
|
|
std::optional< ::Ifc4::IfcElementCompositionEnum::Value > Ifc4::IfcSpatialStructureElement::CompositionType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcElementCompositionEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcSpatialStructureElement::setCompositionType(const std::optional< ::Ifc4::IfcElementCompositionEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcElementCompositionEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSpatialStructureElement::Class() { return *((IfcParse::entity*)IFC4_types[930]); }
|
|
void Ifc4::IfcSpatialStructureElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_LongName, std::optional< ::Ifc4::IfcElementCompositionEnum::Value > v9_CompositionType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_LongName) {set_attribute_value(7, (*v8_LongName)); } if (v9_CompositionType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcElementCompositionEnum::Class(),(size_t)*v9_CompositionType))); } }
|
|
|
|
// Function implementations for IfcSpatialStructureElementType
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSpatialStructureElementType::Class() { return *((IfcParse::entity*)IFC4_types[931]); }
|
|
void Ifc4::IfcSpatialStructureElementType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } }
|
|
|
|
// Function implementations for IfcSpatialZone
|
|
std::optional< ::Ifc4::IfcSpatialZoneTypeEnum::Value > Ifc4::IfcSpatialZone::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcSpatialZoneTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcSpatialZone::setPredefinedType(const std::optional< ::Ifc4::IfcSpatialZoneTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcSpatialZoneTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSpatialZone::Class() { return *((IfcParse::entity*)IFC4_types[932]); }
|
|
void Ifc4::IfcSpatialZone::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_LongName, std::optional< ::Ifc4::IfcSpatialZoneTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_LongName) {set_attribute_value(7, (*v8_LongName)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcSpatialZoneTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcSpatialZoneType
|
|
::Ifc4::IfcSpatialZoneTypeEnum::Value Ifc4::IfcSpatialZoneType::PredefinedType() const { return ::Ifc4::IfcSpatialZoneTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcSpatialZoneType::setPredefinedType(const ::Ifc4::IfcSpatialZoneTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcSpatialZoneTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
std::optional< std::string > Ifc4::IfcSpatialZoneType::LongName() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } std::string v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcSpatialZoneType::setLongName(const std::optional< std::string >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSpatialZoneType::Class() { return *((IfcParse::entity*)IFC4_types[933]); }
|
|
void Ifc4::IfcSpatialZoneType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcSpatialZoneTypeEnum::Value v10_PredefinedType, std::optional< std::string > v11_LongName) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcSpatialZoneTypeEnum::Class(),(size_t)v10_PredefinedType))); if (v11_LongName) {set_attribute_value(10, (*v11_LongName)); } }
|
|
|
|
// Function implementations for IfcSphere
|
|
double Ifc4::IfcSphere::Radius() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcSphere::setRadius(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSphere::Class() { return *((IfcParse::entity*)IFC4_types[939]); }
|
|
void Ifc4::IfcSphere::initialize(::Ifc4::IfcAxis2Placement3D v1_Position, double v2_Radius) { set_attribute_value(0, (v1_Position));set_attribute_value(1, (v2_Radius)); }
|
|
|
|
// Function implementations for IfcSphericalSurface
|
|
double Ifc4::IfcSphericalSurface::Radius() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcSphericalSurface::setRadius(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSphericalSurface::Class() { return *((IfcParse::entity*)IFC4_types[940]); }
|
|
void Ifc4::IfcSphericalSurface::initialize(::Ifc4::IfcAxis2Placement3D v1_Position, double v2_Radius) { set_attribute_value(0, (v1_Position));set_attribute_value(1, (v2_Radius)); }
|
|
|
|
// Function implementations for IfcStackTerminal
|
|
std::optional< ::Ifc4::IfcStackTerminalTypeEnum::Value > Ifc4::IfcStackTerminal::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcStackTerminalTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcStackTerminal::setPredefinedType(const std::optional< ::Ifc4::IfcStackTerminalTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcStackTerminalTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStackTerminal::Class() { return *((IfcParse::entity*)IFC4_types[941]); }
|
|
void Ifc4::IfcStackTerminal::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcStackTerminalTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcStackTerminalTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcStackTerminalType
|
|
::Ifc4::IfcStackTerminalTypeEnum::Value Ifc4::IfcStackTerminalType::PredefinedType() const { return ::Ifc4::IfcStackTerminalTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcStackTerminalType::setPredefinedType(const ::Ifc4::IfcStackTerminalTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcStackTerminalTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStackTerminalType::Class() { return *((IfcParse::entity*)IFC4_types[942]); }
|
|
void Ifc4::IfcStackTerminalType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcStackTerminalTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcStackTerminalTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcStair
|
|
std::optional< ::Ifc4::IfcStairTypeEnum::Value > Ifc4::IfcStair::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcStairTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcStair::setPredefinedType(const std::optional< ::Ifc4::IfcStairTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcStairTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStair::Class() { return *((IfcParse::entity*)IFC4_types[944]); }
|
|
void Ifc4::IfcStair::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcStairTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcStairTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcStairFlight
|
|
std::optional< int > Ifc4::IfcStairFlight::NumberOfRisers() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } int v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcStairFlight::setNumberOfRisers(const std::optional< int >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
std::optional< int > Ifc4::IfcStairFlight::NumberOfTreads() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } int v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcStairFlight::setNumberOfTreads(const std::optional< int >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
std::optional< double > Ifc4::IfcStairFlight::RiserHeight() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } double v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcStairFlight::setRiserHeight(const std::optional< double >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::optional< double > Ifc4::IfcStairFlight::TreadLength() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } double v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcStairFlight::setTreadLength(const std::optional< double >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
std::optional< ::Ifc4::IfcStairFlightTypeEnum::Value > Ifc4::IfcStairFlight::PredefinedType() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } return ::Ifc4::IfcStairFlightTypeEnum::FromString(get_attribute_value(12)); }
|
|
void Ifc4::IfcStairFlight::setPredefinedType(const std::optional< ::Ifc4::IfcStairFlightTypeEnum::Value >& v) { if (v) {set_attribute_value(12, EnumerationReference(&::Ifc4::IfcStairFlightTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(12);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStairFlight::Class() { return *((IfcParse::entity*)IFC4_types[945]); }
|
|
void Ifc4::IfcStairFlight::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< int > v9_NumberOfRisers, std::optional< int > v10_NumberOfTreads, std::optional< double > v11_RiserHeight, std::optional< double > v12_TreadLength, std::optional< ::Ifc4::IfcStairFlightTypeEnum::Value > v13_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_NumberOfRisers) {set_attribute_value(8, (*v9_NumberOfRisers)); } 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)); } if (v13_PredefinedType) {set_attribute_value(12, (EnumerationReference(&::Ifc4::IfcStairFlightTypeEnum::Class(),(size_t)*v13_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcStairFlightType
|
|
::Ifc4::IfcStairFlightTypeEnum::Value Ifc4::IfcStairFlightType::PredefinedType() const { return ::Ifc4::IfcStairFlightTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcStairFlightType::setPredefinedType(const ::Ifc4::IfcStairFlightTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcStairFlightTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStairFlightType::Class() { return *((IfcParse::entity*)IFC4_types[946]); }
|
|
void Ifc4::IfcStairFlightType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcStairFlightTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcStairFlightTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcStairType
|
|
::Ifc4::IfcStairTypeEnum::Value Ifc4::IfcStairType::PredefinedType() const { return ::Ifc4::IfcStairTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcStairType::setPredefinedType(const ::Ifc4::IfcStairTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcStairTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStairType::Class() { return *((IfcParse::entity*)IFC4_types[948]); }
|
|
void Ifc4::IfcStairType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcStairTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcStairTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcStructuralAction
|
|
std::optional< bool > Ifc4::IfcStructuralAction::DestabilizingLoad() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } bool v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcStructuralAction::setDestabilizingLoad(const std::optional< bool >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralAction::Class() { return *((IfcParse::entity*)IFC4_types[951]); }
|
|
void Ifc4::IfcStructuralAction::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcStructuralLoad v8_AppliedLoad, ::Ifc4::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal, std::optional< bool > v10_DestabilizingLoad) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (v8_AppliedLoad));set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal))); if (v10_DestabilizingLoad) {set_attribute_value(9, (*v10_DestabilizingLoad)); } }
|
|
|
|
// Function implementations for IfcStructuralActivity
|
|
::Ifc4::IfcStructuralLoad Ifc4::IfcStructuralActivity::AppliedLoad() const { return ((express::Base)(get_attribute_value(7))).as<::Ifc4::IfcStructuralLoad>(); }
|
|
void Ifc4::IfcStructuralActivity::setAppliedLoad(const ::Ifc4::IfcStructuralLoad& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
::Ifc4::IfcGlobalOrLocalEnum::Value Ifc4::IfcStructuralActivity::GlobalOrLocal() const { return ::Ifc4::IfcGlobalOrLocalEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcStructuralActivity::setGlobalOrLocal(const ::Ifc4::IfcGlobalOrLocalEnum::Value& v) { set_attribute_value(8, EnumerationReference(&::Ifc4::IfcGlobalOrLocalEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }
|
|
|
|
std::vector<::Ifc4::IfcRelConnectsStructuralActivity> Ifc4::IfcStructuralActivity::AssignedToStructuralItem() const { return cast_vector<IfcRelConnectsStructuralActivity>(file()->getInverse(data()->id(), IFC4_types[819], 5)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralActivity::Class() { return *((IfcParse::entity*)IFC4_types[952]); }
|
|
void Ifc4::IfcStructuralActivity::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcStructuralLoad v8_AppliedLoad, ::Ifc4::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (v8_AppliedLoad));set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal))); }
|
|
|
|
// Function implementations for IfcStructuralAnalysisModel
|
|
::Ifc4::IfcAnalysisModelTypeEnum::Value Ifc4::IfcStructuralAnalysisModel::PredefinedType() const { return ::Ifc4::IfcAnalysisModelTypeEnum::FromString(get_attribute_value(5)); }
|
|
void Ifc4::IfcStructuralAnalysisModel::setPredefinedType(const ::Ifc4::IfcAnalysisModelTypeEnum::Value& v) { set_attribute_value(5, EnumerationReference(&::Ifc4::IfcAnalysisModelTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(5); }
|
|
::Ifc4::IfcAxis2Placement3D Ifc4::IfcStructuralAnalysisModel::OrientationOf2DPlane() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcAxis2Placement3D{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcAxis2Placement3D>(); }
|
|
void Ifc4::IfcStructuralAnalysisModel::setOrientationOf2DPlane(const ::Ifc4::IfcAxis2Placement3D& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
std::optional< std::vector< ::Ifc4::IfcStructuralLoadGroup > > Ifc4::IfcStructuralAnalysisModel::LoadedBy() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(7); return cast_vector<::Ifc4::IfcStructuralLoadGroup>(es); }
|
|
void Ifc4::IfcStructuralAnalysisModel::setLoadedBy(const std::optional< std::vector< ::Ifc4::IfcStructuralLoadGroup > >& v) { if (v) {set_attribute_value(7, cast_vector<express::Base>(*v));} else {unset_attribute_value(7);} }
|
|
std::optional< std::vector< ::Ifc4::IfcStructuralResultGroup > > Ifc4::IfcStructuralAnalysisModel::HasResults() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(8); return cast_vector<::Ifc4::IfcStructuralResultGroup>(es); }
|
|
void Ifc4::IfcStructuralAnalysisModel::setHasResults(const std::optional< std::vector< ::Ifc4::IfcStructuralResultGroup > >& v) { if (v) {set_attribute_value(8, cast_vector<express::Base>(*v));} else {unset_attribute_value(8);} }
|
|
::Ifc4::IfcObjectPlacement Ifc4::IfcStructuralAnalysisModel::SharedPlacement() const { if(get_attribute_value(9).isNull()) { return ::Ifc4::IfcObjectPlacement{}; } return ((express::Base)(get_attribute_value(9))).as<::Ifc4::IfcObjectPlacement>(); }
|
|
void Ifc4::IfcStructuralAnalysisModel::setSharedPlacement(const ::Ifc4::IfcObjectPlacement& v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralAnalysisModel::Class() { return *((IfcParse::entity*)IFC4_types[954]); }
|
|
void Ifc4::IfcStructuralAnalysisModel::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcAnalysisModelTypeEnum::Value v6_PredefinedType, ::Ifc4::IfcAxis2Placement3D v7_OrientationOf2DPlane, std::optional< std::vector< ::Ifc4::IfcStructuralLoadGroup > > v8_LoadedBy, std::optional< std::vector< ::Ifc4::IfcStructuralResultGroup > > v9_HasResults, ::Ifc4::IfcObjectPlacement v10_SharedPlacement) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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(&::Ifc4::IfcAnalysisModelTypeEnum::Class(),(size_t)v6_PredefinedType)));set_attribute_value(6, (v7_OrientationOf2DPlane)); if (v8_LoadedBy) {set_attribute_value(7, cast_vector<express::Base>(*v8_LoadedBy)); } if (v9_HasResults) {set_attribute_value(8, cast_vector<express::Base>(*v9_HasResults)); }set_attribute_value(9, (v10_SharedPlacement)); }
|
|
|
|
// Function implementations for IfcStructuralConnection
|
|
::Ifc4::IfcBoundaryCondition Ifc4::IfcStructuralConnection::AppliedCondition() const { if(get_attribute_value(7).isNull()) { return ::Ifc4::IfcBoundaryCondition{}; } return ((express::Base)(get_attribute_value(7))).as<::Ifc4::IfcBoundaryCondition>(); }
|
|
void Ifc4::IfcStructuralConnection::setAppliedCondition(const ::Ifc4::IfcBoundaryCondition& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
|
|
std::vector<::Ifc4::IfcRelConnectsStructuralMember> Ifc4::IfcStructuralConnection::ConnectsStructuralMembers() const { return cast_vector<IfcRelConnectsStructuralMember>(file()->getInverse(data()->id(), IFC4_types[820], 5)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralConnection::Class() { return *((IfcParse::entity*)IFC4_types[955]); }
|
|
void Ifc4::IfcStructuralConnection::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcBoundaryCondition v8_AppliedCondition) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (v8_AppliedCondition)); }
|
|
|
|
// Function implementations for IfcStructuralConnectionCondition
|
|
std::optional< std::string > Ifc4::IfcStructuralConnectionCondition::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcStructuralConnectionCondition::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralConnectionCondition::Class() { return *((IfcParse::entity*)IFC4_types[956]); }
|
|
void Ifc4::IfcStructuralConnectionCondition::initialize(std::optional< std::string > v1_Name) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } }
|
|
|
|
// Function implementations for IfcStructuralCurveAction
|
|
std::optional< ::Ifc4::IfcProjectedOrTrueLengthEnum::Value > Ifc4::IfcStructuralCurveAction::ProjectedOrTrue() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } return ::Ifc4::IfcProjectedOrTrueLengthEnum::FromString(get_attribute_value(10)); }
|
|
void Ifc4::IfcStructuralCurveAction::setProjectedOrTrue(const std::optional< ::Ifc4::IfcProjectedOrTrueLengthEnum::Value >& v) { if (v) {set_attribute_value(10, EnumerationReference(&::Ifc4::IfcProjectedOrTrueLengthEnum::Class(), (size_t) *v));} else {unset_attribute_value(10);} }
|
|
::Ifc4::IfcStructuralCurveActivityTypeEnum::Value Ifc4::IfcStructuralCurveAction::PredefinedType() const { return ::Ifc4::IfcStructuralCurveActivityTypeEnum::FromString(get_attribute_value(11)); }
|
|
void Ifc4::IfcStructuralCurveAction::setPredefinedType(const ::Ifc4::IfcStructuralCurveActivityTypeEnum::Value& v) { set_attribute_value(11, EnumerationReference(&::Ifc4::IfcStructuralCurveActivityTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(11); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralCurveAction::Class() { return *((IfcParse::entity*)IFC4_types[957]); }
|
|
void Ifc4::IfcStructuralCurveAction::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcStructuralLoad v8_AppliedLoad, ::Ifc4::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal, std::optional< bool > v10_DestabilizingLoad, std::optional< ::Ifc4::IfcProjectedOrTrueLengthEnum::Value > v11_ProjectedOrTrue, ::Ifc4::IfcStructuralCurveActivityTypeEnum::Value v12_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (v8_AppliedLoad));set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal))); if (v10_DestabilizingLoad) {set_attribute_value(9, (*v10_DestabilizingLoad)); } if (v11_ProjectedOrTrue) {set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcProjectedOrTrueLengthEnum::Class(),(size_t)*v11_ProjectedOrTrue))); }set_attribute_value(11, (EnumerationReference(&::Ifc4::IfcStructuralCurveActivityTypeEnum::Class(),(size_t)v12_PredefinedType))); }
|
|
|
|
// Function implementations for IfcStructuralCurveConnection
|
|
::Ifc4::IfcDirection Ifc4::IfcStructuralCurveConnection::Axis() const { return ((express::Base)(get_attribute_value(8))).as<::Ifc4::IfcDirection>(); }
|
|
void Ifc4::IfcStructuralCurveConnection::setAxis(const ::Ifc4::IfcDirection& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralCurveConnection::Class() { return *((IfcParse::entity*)IFC4_types[959]); }
|
|
void Ifc4::IfcStructuralCurveConnection::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcBoundaryCondition v8_AppliedCondition, ::Ifc4::IfcDirection v9_Axis) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (v8_AppliedCondition));set_attribute_value(8, (v9_Axis)); }
|
|
|
|
// Function implementations for IfcStructuralCurveMember
|
|
::Ifc4::IfcStructuralCurveMemberTypeEnum::Value Ifc4::IfcStructuralCurveMember::PredefinedType() const { return ::Ifc4::IfcStructuralCurveMemberTypeEnum::FromString(get_attribute_value(7)); }
|
|
void Ifc4::IfcStructuralCurveMember::setPredefinedType(const ::Ifc4::IfcStructuralCurveMemberTypeEnum::Value& v) { set_attribute_value(7, EnumerationReference(&::Ifc4::IfcStructuralCurveMemberTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }
|
|
::Ifc4::IfcDirection Ifc4::IfcStructuralCurveMember::Axis() const { return ((express::Base)(get_attribute_value(8))).as<::Ifc4::IfcDirection>(); }
|
|
void Ifc4::IfcStructuralCurveMember::setAxis(const ::Ifc4::IfcDirection& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralCurveMember::Class() { return *((IfcParse::entity*)IFC4_types[960]); }
|
|
void Ifc4::IfcStructuralCurveMember::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcStructuralCurveMemberTypeEnum::Value v8_PredefinedType, ::Ifc4::IfcDirection v9_Axis) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcStructuralCurveMemberTypeEnum::Class(),(size_t)v8_PredefinedType)));set_attribute_value(8, (v9_Axis)); }
|
|
|
|
// Function implementations for IfcStructuralCurveMemberVarying
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralCurveMemberVarying::Class() { return *((IfcParse::entity*)IFC4_types[962]); }
|
|
void Ifc4::IfcStructuralCurveMemberVarying::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcStructuralCurveMemberTypeEnum::Value v8_PredefinedType, ::Ifc4::IfcDirection v9_Axis) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcStructuralCurveMemberTypeEnum::Class(),(size_t)v8_PredefinedType)));set_attribute_value(8, (v9_Axis)); }
|
|
|
|
// Function implementations for IfcStructuralCurveReaction
|
|
::Ifc4::IfcStructuralCurveActivityTypeEnum::Value Ifc4::IfcStructuralCurveReaction::PredefinedType() const { return ::Ifc4::IfcStructuralCurveActivityTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcStructuralCurveReaction::setPredefinedType(const ::Ifc4::IfcStructuralCurveActivityTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcStructuralCurveActivityTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralCurveReaction::Class() { return *((IfcParse::entity*)IFC4_types[963]); }
|
|
void Ifc4::IfcStructuralCurveReaction::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcStructuralLoad v8_AppliedLoad, ::Ifc4::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal, ::Ifc4::IfcStructuralCurveActivityTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (v8_AppliedLoad));set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal)));set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcStructuralCurveActivityTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcStructuralItem
|
|
|
|
std::vector<::Ifc4::IfcRelConnectsStructuralActivity> Ifc4::IfcStructuralItem::AssignedStructuralActivity() const { return cast_vector<IfcRelConnectsStructuralActivity>(file()->getInverse(data()->id(), IFC4_types[819], 4)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralItem::Class() { return *((IfcParse::entity*)IFC4_types[964]); }
|
|
void Ifc4::IfcStructuralItem::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); }
|
|
|
|
// Function implementations for IfcStructuralLinearAction
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralLinearAction::Class() { return *((IfcParse::entity*)IFC4_types[965]); }
|
|
void Ifc4::IfcStructuralLinearAction::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcStructuralLoad v8_AppliedLoad, ::Ifc4::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal, std::optional< bool > v10_DestabilizingLoad, std::optional< ::Ifc4::IfcProjectedOrTrueLengthEnum::Value > v11_ProjectedOrTrue, ::Ifc4::IfcStructuralCurveActivityTypeEnum::Value v12_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (v8_AppliedLoad));set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal))); if (v10_DestabilizingLoad) {set_attribute_value(9, (*v10_DestabilizingLoad)); } if (v11_ProjectedOrTrue) {set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcProjectedOrTrueLengthEnum::Class(),(size_t)*v11_ProjectedOrTrue))); }set_attribute_value(11, (EnumerationReference(&::Ifc4::IfcStructuralCurveActivityTypeEnum::Class(),(size_t)v12_PredefinedType))); }
|
|
|
|
// Function implementations for IfcStructuralLoad
|
|
std::optional< std::string > Ifc4::IfcStructuralLoad::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcStructuralLoad::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralLoad::Class() { return *((IfcParse::entity*)IFC4_types[966]); }
|
|
void Ifc4::IfcStructuralLoad::initialize(std::optional< std::string > v1_Name) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } }
|
|
|
|
// Function implementations for IfcStructuralLoadCase
|
|
std::optional< std::vector< double > /*[3:3]*/ > Ifc4::IfcStructuralLoadCase::SelfWeightCoefficients() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } std::vector< double > /*[3:3]*/ v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcStructuralLoadCase::setSelfWeightCoefficients(const std::optional< std::vector< double > /*[3:3]*/ >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralLoadCase::Class() { return *((IfcParse::entity*)IFC4_types[967]); }
|
|
void Ifc4::IfcStructuralLoadCase::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcLoadGroupTypeEnum::Value v6_PredefinedType, ::Ifc4::IfcActionTypeEnum::Value v7_ActionType, ::Ifc4::IfcActionSourceTypeEnum::Value v8_ActionSource, std::optional< double > v9_Coefficient, std::optional< std::string > v10_Purpose, std::optional< std::vector< double > /*[3:3]*/ > v11_SelfWeightCoefficients) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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(&::Ifc4::IfcLoadGroupTypeEnum::Class(),(size_t)v6_PredefinedType)));set_attribute_value(6, (EnumerationReference(&::Ifc4::IfcActionTypeEnum::Class(),(size_t)v7_ActionType)));set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcActionSourceTypeEnum::Class(),(size_t)v8_ActionSource))); if (v9_Coefficient) {set_attribute_value(8, (*v9_Coefficient)); } if (v10_Purpose) {set_attribute_value(9, (*v10_Purpose)); } if (v11_SelfWeightCoefficients) {set_attribute_value(10, (*v11_SelfWeightCoefficients)); } }
|
|
|
|
// Function implementations for IfcStructuralLoadConfiguration
|
|
std::vector< ::Ifc4::IfcStructuralLoadOrResult > Ifc4::IfcStructuralLoadConfiguration::Values() const { std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcStructuralLoadOrResult>(es); }
|
|
void Ifc4::IfcStructuralLoadConfiguration::setValues(const std::vector< ::Ifc4::IfcStructuralLoadOrResult >& v) { set_attribute_value(1, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(1); }
|
|
std::optional< std::vector< std::vector< double > > > Ifc4::IfcStructuralLoadConfiguration::Locations() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::vector< std::vector< double > > v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcStructuralLoadConfiguration::setLocations(const std::optional< std::vector< std::vector< double > > >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralLoadConfiguration::Class() { return *((IfcParse::entity*)IFC4_types[968]); }
|
|
void Ifc4::IfcStructuralLoadConfiguration::initialize(std::optional< std::string > v1_Name, std::vector< ::Ifc4::IfcStructuralLoadOrResult > v2_Values, std::optional< std::vector< std::vector< double > > > v3_Locations) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, cast_vector<express::Base>(v2_Values)); if (v3_Locations) {set_attribute_value(2, (*v3_Locations)); } }
|
|
|
|
// Function implementations for IfcStructuralLoadGroup
|
|
::Ifc4::IfcLoadGroupTypeEnum::Value Ifc4::IfcStructuralLoadGroup::PredefinedType() const { return ::Ifc4::IfcLoadGroupTypeEnum::FromString(get_attribute_value(5)); }
|
|
void Ifc4::IfcStructuralLoadGroup::setPredefinedType(const ::Ifc4::IfcLoadGroupTypeEnum::Value& v) { set_attribute_value(5, EnumerationReference(&::Ifc4::IfcLoadGroupTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(5); }
|
|
::Ifc4::IfcActionTypeEnum::Value Ifc4::IfcStructuralLoadGroup::ActionType() const { return ::Ifc4::IfcActionTypeEnum::FromString(get_attribute_value(6)); }
|
|
void Ifc4::IfcStructuralLoadGroup::setActionType(const ::Ifc4::IfcActionTypeEnum::Value& v) { set_attribute_value(6, EnumerationReference(&::Ifc4::IfcActionTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(6); }
|
|
::Ifc4::IfcActionSourceTypeEnum::Value Ifc4::IfcStructuralLoadGroup::ActionSource() const { return ::Ifc4::IfcActionSourceTypeEnum::FromString(get_attribute_value(7)); }
|
|
void Ifc4::IfcStructuralLoadGroup::setActionSource(const ::Ifc4::IfcActionSourceTypeEnum::Value& v) { set_attribute_value(7, EnumerationReference(&::Ifc4::IfcActionSourceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }
|
|
std::optional< double > Ifc4::IfcStructuralLoadGroup::Coefficient() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } double v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcStructuralLoadGroup::setCoefficient(const std::optional< double >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
std::optional< std::string > Ifc4::IfcStructuralLoadGroup::Purpose() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } std::string v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcStructuralLoadGroup::setPurpose(const std::optional< std::string >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
|
|
std::vector<::Ifc4::IfcStructuralResultGroup> Ifc4::IfcStructuralLoadGroup::SourceOfResultGroup() const { return cast_vector<IfcStructuralResultGroup>(file()->getInverse(data()->id(), IFC4_types[985], 6)); }
|
|
std::vector<::Ifc4::IfcStructuralAnalysisModel> Ifc4::IfcStructuralLoadGroup::LoadGroupFor() const { return cast_vector<IfcStructuralAnalysisModel>(file()->getInverse(data()->id(), IFC4_types[954], 7)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralLoadGroup::Class() { return *((IfcParse::entity*)IFC4_types[969]); }
|
|
void Ifc4::IfcStructuralLoadGroup::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcLoadGroupTypeEnum::Value v6_PredefinedType, ::Ifc4::IfcActionTypeEnum::Value v7_ActionType, ::Ifc4::IfcActionSourceTypeEnum::Value v8_ActionSource, std::optional< double > v9_Coefficient, std::optional< std::string > v10_Purpose) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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(&::Ifc4::IfcLoadGroupTypeEnum::Class(),(size_t)v6_PredefinedType)));set_attribute_value(6, (EnumerationReference(&::Ifc4::IfcActionTypeEnum::Class(),(size_t)v7_ActionType)));set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcActionSourceTypeEnum::Class(),(size_t)v8_ActionSource))); if (v9_Coefficient) {set_attribute_value(8, (*v9_Coefficient)); } if (v10_Purpose) {set_attribute_value(9, (*v10_Purpose)); } }
|
|
|
|
// Function implementations for IfcStructuralLoadLinearForce
|
|
std::optional< double > Ifc4::IfcStructuralLoadLinearForce::LinearForceX() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcStructuralLoadLinearForce::setLinearForceX(const std::optional< double >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadLinearForce::LinearForceY() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcStructuralLoadLinearForce::setLinearForceY(const std::optional< double >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadLinearForce::LinearForceZ() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcStructuralLoadLinearForce::setLinearForceZ(const std::optional< double >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadLinearForce::LinearMomentX() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcStructuralLoadLinearForce::setLinearMomentX(const std::optional< double >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadLinearForce::LinearMomentY() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcStructuralLoadLinearForce::setLinearMomentY(const std::optional< double >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadLinearForce::LinearMomentZ() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcStructuralLoadLinearForce::setLinearMomentZ(const std::optional< double >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralLoadLinearForce::Class() { return *((IfcParse::entity*)IFC4_types[970]); }
|
|
void Ifc4::IfcStructuralLoadLinearForce::initialize(std::optional< std::string > v1_Name, std::optional< double > v2_LinearForceX, std::optional< double > v3_LinearForceY, std::optional< double > v4_LinearForceZ, std::optional< double > v5_LinearMomentX, std::optional< double > v6_LinearMomentY, std::optional< double > v7_LinearMomentZ) { 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)); } }
|
|
|
|
// Function implementations for IfcStructuralLoadOrResult
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralLoadOrResult::Class() { return *((IfcParse::entity*)IFC4_types[971]); }
|
|
void Ifc4::IfcStructuralLoadOrResult::initialize(std::optional< std::string > v1_Name) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } }
|
|
|
|
// Function implementations for IfcStructuralLoadPlanarForce
|
|
std::optional< double > Ifc4::IfcStructuralLoadPlanarForce::PlanarForceX() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcStructuralLoadPlanarForce::setPlanarForceX(const std::optional< double >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadPlanarForce::PlanarForceY() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcStructuralLoadPlanarForce::setPlanarForceY(const std::optional< double >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadPlanarForce::PlanarForceZ() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcStructuralLoadPlanarForce::setPlanarForceZ(const std::optional< double >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralLoadPlanarForce::Class() { return *((IfcParse::entity*)IFC4_types[972]); }
|
|
void Ifc4::IfcStructuralLoadPlanarForce::initialize(std::optional< std::string > v1_Name, std::optional< double > v2_PlanarForceX, std::optional< double > v3_PlanarForceY, std::optional< double > v4_PlanarForceZ) { 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)); } }
|
|
|
|
// Function implementations for IfcStructuralLoadSingleDisplacement
|
|
std::optional< double > Ifc4::IfcStructuralLoadSingleDisplacement::DisplacementX() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcStructuralLoadSingleDisplacement::setDisplacementX(const std::optional< double >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadSingleDisplacement::DisplacementY() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcStructuralLoadSingleDisplacement::setDisplacementY(const std::optional< double >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadSingleDisplacement::DisplacementZ() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcStructuralLoadSingleDisplacement::setDisplacementZ(const std::optional< double >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadSingleDisplacement::RotationalDisplacementRX() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcStructuralLoadSingleDisplacement::setRotationalDisplacementRX(const std::optional< double >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadSingleDisplacement::RotationalDisplacementRY() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcStructuralLoadSingleDisplacement::setRotationalDisplacementRY(const std::optional< double >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadSingleDisplacement::RotationalDisplacementRZ() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcStructuralLoadSingleDisplacement::setRotationalDisplacementRZ(const std::optional< double >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralLoadSingleDisplacement::Class() { return *((IfcParse::entity*)IFC4_types[973]); }
|
|
void Ifc4::IfcStructuralLoadSingleDisplacement::initialize(std::optional< std::string > v1_Name, std::optional< double > v2_DisplacementX, std::optional< double > v3_DisplacementY, std::optional< double > v4_DisplacementZ, std::optional< double > v5_RotationalDisplacementRX, std::optional< double > v6_RotationalDisplacementRY, std::optional< double > v7_RotationalDisplacementRZ) { 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)); } }
|
|
|
|
// Function implementations for IfcStructuralLoadSingleDisplacementDistortion
|
|
std::optional< double > Ifc4::IfcStructuralLoadSingleDisplacementDistortion::Distortion() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcStructuralLoadSingleDisplacementDistortion::setDistortion(const std::optional< double >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralLoadSingleDisplacementDistortion::Class() { return *((IfcParse::entity*)IFC4_types[974]); }
|
|
void Ifc4::IfcStructuralLoadSingleDisplacementDistortion::initialize(std::optional< std::string > v1_Name, std::optional< double > v2_DisplacementX, std::optional< double > v3_DisplacementY, std::optional< double > v4_DisplacementZ, std::optional< double > v5_RotationalDisplacementRX, std::optional< double > v6_RotationalDisplacementRY, std::optional< double > v7_RotationalDisplacementRZ, std::optional< double > v8_Distortion) { 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)); } }
|
|
|
|
// Function implementations for IfcStructuralLoadSingleForce
|
|
std::optional< double > Ifc4::IfcStructuralLoadSingleForce::ForceX() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcStructuralLoadSingleForce::setForceX(const std::optional< double >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadSingleForce::ForceY() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcStructuralLoadSingleForce::setForceY(const std::optional< double >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadSingleForce::ForceZ() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcStructuralLoadSingleForce::setForceZ(const std::optional< double >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadSingleForce::MomentX() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcStructuralLoadSingleForce::setMomentX(const std::optional< double >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadSingleForce::MomentY() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcStructuralLoadSingleForce::setMomentY(const std::optional< double >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadSingleForce::MomentZ() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcStructuralLoadSingleForce::setMomentZ(const std::optional< double >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralLoadSingleForce::Class() { return *((IfcParse::entity*)IFC4_types[975]); }
|
|
void Ifc4::IfcStructuralLoadSingleForce::initialize(std::optional< std::string > v1_Name, std::optional< double > v2_ForceX, std::optional< double > v3_ForceY, std::optional< double > v4_ForceZ, std::optional< double > v5_MomentX, std::optional< double > v6_MomentY, std::optional< double > v7_MomentZ) { 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)); } }
|
|
|
|
// Function implementations for IfcStructuralLoadSingleForceWarping
|
|
std::optional< double > Ifc4::IfcStructuralLoadSingleForceWarping::WarpingMoment() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcStructuralLoadSingleForceWarping::setWarpingMoment(const std::optional< double >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralLoadSingleForceWarping::Class() { return *((IfcParse::entity*)IFC4_types[976]); }
|
|
void Ifc4::IfcStructuralLoadSingleForceWarping::initialize(std::optional< std::string > v1_Name, std::optional< double > v2_ForceX, std::optional< double > v3_ForceY, std::optional< double > v4_ForceZ, std::optional< double > v5_MomentX, std::optional< double > v6_MomentY, std::optional< double > v7_MomentZ, std::optional< double > v8_WarpingMoment) { 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)); } }
|
|
|
|
// Function implementations for IfcStructuralLoadStatic
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralLoadStatic::Class() { return *((IfcParse::entity*)IFC4_types[977]); }
|
|
void Ifc4::IfcStructuralLoadStatic::initialize(std::optional< std::string > v1_Name) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } }
|
|
|
|
// Function implementations for IfcStructuralLoadTemperature
|
|
std::optional< double > Ifc4::IfcStructuralLoadTemperature::DeltaTConstant() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcStructuralLoadTemperature::setDeltaTConstant(const std::optional< double >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadTemperature::DeltaTY() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcStructuralLoadTemperature::setDeltaTY(const std::optional< double >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< double > Ifc4::IfcStructuralLoadTemperature::DeltaTZ() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcStructuralLoadTemperature::setDeltaTZ(const std::optional< double >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralLoadTemperature::Class() { return *((IfcParse::entity*)IFC4_types[978]); }
|
|
void Ifc4::IfcStructuralLoadTemperature::initialize(std::optional< std::string > v1_Name, std::optional< double > v2_DeltaTConstant, std::optional< double > v3_DeltaTY, std::optional< double > v4_DeltaTZ) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_DeltaTConstant) {set_attribute_value(1, (*v2_DeltaTConstant)); } if (v3_DeltaTY) {set_attribute_value(2, (*v3_DeltaTY)); } if (v4_DeltaTZ) {set_attribute_value(3, (*v4_DeltaTZ)); } }
|
|
|
|
// Function implementations for IfcStructuralMember
|
|
|
|
std::vector<::Ifc4::IfcRelConnectsStructuralMember> Ifc4::IfcStructuralMember::ConnectedBy() const { return cast_vector<IfcRelConnectsStructuralMember>(file()->getInverse(data()->id(), IFC4_types[820], 4)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralMember::Class() { return *((IfcParse::entity*)IFC4_types[979]); }
|
|
void Ifc4::IfcStructuralMember::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); }
|
|
|
|
// Function implementations for IfcStructuralPlanarAction
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralPlanarAction::Class() { return *((IfcParse::entity*)IFC4_types[980]); }
|
|
void Ifc4::IfcStructuralPlanarAction::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcStructuralLoad v8_AppliedLoad, ::Ifc4::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal, std::optional< bool > v10_DestabilizingLoad, std::optional< ::Ifc4::IfcProjectedOrTrueLengthEnum::Value > v11_ProjectedOrTrue, ::Ifc4::IfcStructuralSurfaceActivityTypeEnum::Value v12_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (v8_AppliedLoad));set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal))); if (v10_DestabilizingLoad) {set_attribute_value(9, (*v10_DestabilizingLoad)); } if (v11_ProjectedOrTrue) {set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcProjectedOrTrueLengthEnum::Class(),(size_t)*v11_ProjectedOrTrue))); }set_attribute_value(11, (EnumerationReference(&::Ifc4::IfcStructuralSurfaceActivityTypeEnum::Class(),(size_t)v12_PredefinedType))); }
|
|
|
|
// Function implementations for IfcStructuralPointAction
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralPointAction::Class() { return *((IfcParse::entity*)IFC4_types[981]); }
|
|
void Ifc4::IfcStructuralPointAction::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcStructuralLoad v8_AppliedLoad, ::Ifc4::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal, std::optional< bool > v10_DestabilizingLoad) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (v8_AppliedLoad));set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal))); if (v10_DestabilizingLoad) {set_attribute_value(9, (*v10_DestabilizingLoad)); } }
|
|
|
|
// Function implementations for IfcStructuralPointConnection
|
|
::Ifc4::IfcAxis2Placement3D Ifc4::IfcStructuralPointConnection::ConditionCoordinateSystem() const { if(get_attribute_value(8).isNull()) { return ::Ifc4::IfcAxis2Placement3D{}; } return ((express::Base)(get_attribute_value(8))).as<::Ifc4::IfcAxis2Placement3D>(); }
|
|
void Ifc4::IfcStructuralPointConnection::setConditionCoordinateSystem(const ::Ifc4::IfcAxis2Placement3D& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralPointConnection::Class() { return *((IfcParse::entity*)IFC4_types[982]); }
|
|
void Ifc4::IfcStructuralPointConnection::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcBoundaryCondition v8_AppliedCondition, ::Ifc4::IfcAxis2Placement3D v9_ConditionCoordinateSystem) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (v8_AppliedCondition));set_attribute_value(8, (v9_ConditionCoordinateSystem)); }
|
|
|
|
// Function implementations for IfcStructuralPointReaction
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralPointReaction::Class() { return *((IfcParse::entity*)IFC4_types[983]); }
|
|
void Ifc4::IfcStructuralPointReaction::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcStructuralLoad v8_AppliedLoad, ::Ifc4::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (v8_AppliedLoad));set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal))); }
|
|
|
|
// Function implementations for IfcStructuralReaction
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralReaction::Class() { return *((IfcParse::entity*)IFC4_types[984]); }
|
|
void Ifc4::IfcStructuralReaction::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcStructuralLoad v8_AppliedLoad, ::Ifc4::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (v8_AppliedLoad));set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal))); }
|
|
|
|
// Function implementations for IfcStructuralResultGroup
|
|
::Ifc4::IfcAnalysisTheoryTypeEnum::Value Ifc4::IfcStructuralResultGroup::TheoryType() const { return ::Ifc4::IfcAnalysisTheoryTypeEnum::FromString(get_attribute_value(5)); }
|
|
void Ifc4::IfcStructuralResultGroup::setTheoryType(const ::Ifc4::IfcAnalysisTheoryTypeEnum::Value& v) { set_attribute_value(5, EnumerationReference(&::Ifc4::IfcAnalysisTheoryTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(5); }
|
|
::Ifc4::IfcStructuralLoadGroup Ifc4::IfcStructuralResultGroup::ResultForLoadGroup() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcStructuralLoadGroup{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcStructuralLoadGroup>(); }
|
|
void Ifc4::IfcStructuralResultGroup::setResultForLoadGroup(const ::Ifc4::IfcStructuralLoadGroup& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
bool Ifc4::IfcStructuralResultGroup::IsLinear() const { bool v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcStructuralResultGroup::setIsLinear(const bool& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
|
|
std::vector<::Ifc4::IfcStructuralAnalysisModel> Ifc4::IfcStructuralResultGroup::ResultGroupFor() const { return cast_vector<IfcStructuralAnalysisModel>(file()->getInverse(data()->id(), IFC4_types[954], 8)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralResultGroup::Class() { return *((IfcParse::entity*)IFC4_types[985]); }
|
|
void Ifc4::IfcStructuralResultGroup::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcAnalysisTheoryTypeEnum::Value v6_TheoryType, ::Ifc4::IfcStructuralLoadGroup v7_ResultForLoadGroup, bool v8_IsLinear) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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(&::Ifc4::IfcAnalysisTheoryTypeEnum::Class(),(size_t)v6_TheoryType)));set_attribute_value(6, (v7_ResultForLoadGroup));set_attribute_value(7, (v8_IsLinear)); }
|
|
|
|
// Function implementations for IfcStructuralSurfaceAction
|
|
std::optional< ::Ifc4::IfcProjectedOrTrueLengthEnum::Value > Ifc4::IfcStructuralSurfaceAction::ProjectedOrTrue() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } return ::Ifc4::IfcProjectedOrTrueLengthEnum::FromString(get_attribute_value(10)); }
|
|
void Ifc4::IfcStructuralSurfaceAction::setProjectedOrTrue(const std::optional< ::Ifc4::IfcProjectedOrTrueLengthEnum::Value >& v) { if (v) {set_attribute_value(10, EnumerationReference(&::Ifc4::IfcProjectedOrTrueLengthEnum::Class(), (size_t) *v));} else {unset_attribute_value(10);} }
|
|
::Ifc4::IfcStructuralSurfaceActivityTypeEnum::Value Ifc4::IfcStructuralSurfaceAction::PredefinedType() const { return ::Ifc4::IfcStructuralSurfaceActivityTypeEnum::FromString(get_attribute_value(11)); }
|
|
void Ifc4::IfcStructuralSurfaceAction::setPredefinedType(const ::Ifc4::IfcStructuralSurfaceActivityTypeEnum::Value& v) { set_attribute_value(11, EnumerationReference(&::Ifc4::IfcStructuralSurfaceActivityTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(11); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralSurfaceAction::Class() { return *((IfcParse::entity*)IFC4_types[986]); }
|
|
void Ifc4::IfcStructuralSurfaceAction::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcStructuralLoad v8_AppliedLoad, ::Ifc4::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal, std::optional< bool > v10_DestabilizingLoad, std::optional< ::Ifc4::IfcProjectedOrTrueLengthEnum::Value > v11_ProjectedOrTrue, ::Ifc4::IfcStructuralSurfaceActivityTypeEnum::Value v12_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (v8_AppliedLoad));set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal))); if (v10_DestabilizingLoad) {set_attribute_value(9, (*v10_DestabilizingLoad)); } if (v11_ProjectedOrTrue) {set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcProjectedOrTrueLengthEnum::Class(),(size_t)*v11_ProjectedOrTrue))); }set_attribute_value(11, (EnumerationReference(&::Ifc4::IfcStructuralSurfaceActivityTypeEnum::Class(),(size_t)v12_PredefinedType))); }
|
|
|
|
// Function implementations for IfcStructuralSurfaceConnection
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralSurfaceConnection::Class() { return *((IfcParse::entity*)IFC4_types[988]); }
|
|
void Ifc4::IfcStructuralSurfaceConnection::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcBoundaryCondition v8_AppliedCondition) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (v8_AppliedCondition)); }
|
|
|
|
// Function implementations for IfcStructuralSurfaceMember
|
|
::Ifc4::IfcStructuralSurfaceMemberTypeEnum::Value Ifc4::IfcStructuralSurfaceMember::PredefinedType() const { return ::Ifc4::IfcStructuralSurfaceMemberTypeEnum::FromString(get_attribute_value(7)); }
|
|
void Ifc4::IfcStructuralSurfaceMember::setPredefinedType(const ::Ifc4::IfcStructuralSurfaceMemberTypeEnum::Value& v) { set_attribute_value(7, EnumerationReference(&::Ifc4::IfcStructuralSurfaceMemberTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(7); }
|
|
std::optional< double > Ifc4::IfcStructuralSurfaceMember::Thickness() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } double v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcStructuralSurfaceMember::setThickness(const std::optional< double >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralSurfaceMember::Class() { return *((IfcParse::entity*)IFC4_types[989]); }
|
|
void Ifc4::IfcStructuralSurfaceMember::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcStructuralSurfaceMemberTypeEnum::Value v8_PredefinedType, std::optional< double > v9_Thickness) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcStructuralSurfaceMemberTypeEnum::Class(),(size_t)v8_PredefinedType))); if (v9_Thickness) {set_attribute_value(8, (*v9_Thickness)); } }
|
|
|
|
// Function implementations for IfcStructuralSurfaceMemberVarying
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralSurfaceMemberVarying::Class() { return *((IfcParse::entity*)IFC4_types[991]); }
|
|
void Ifc4::IfcStructuralSurfaceMemberVarying::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcStructuralSurfaceMemberTypeEnum::Value v8_PredefinedType, std::optional< double > v9_Thickness) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (EnumerationReference(&::Ifc4::IfcStructuralSurfaceMemberTypeEnum::Class(),(size_t)v8_PredefinedType))); if (v9_Thickness) {set_attribute_value(8, (*v9_Thickness)); } }
|
|
|
|
// Function implementations for IfcStructuralSurfaceReaction
|
|
::Ifc4::IfcStructuralSurfaceActivityTypeEnum::Value Ifc4::IfcStructuralSurfaceReaction::PredefinedType() const { return ::Ifc4::IfcStructuralSurfaceActivityTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcStructuralSurfaceReaction::setPredefinedType(const ::Ifc4::IfcStructuralSurfaceActivityTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcStructuralSurfaceActivityTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStructuralSurfaceReaction::Class() { return *((IfcParse::entity*)IFC4_types[992]); }
|
|
void Ifc4::IfcStructuralSurfaceReaction::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, ::Ifc4::IfcStructuralLoad v8_AppliedLoad, ::Ifc4::IfcGlobalOrLocalEnum::Value v9_GlobalOrLocal, ::Ifc4::IfcStructuralSurfaceActivityTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation));set_attribute_value(7, (v8_AppliedLoad));set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcGlobalOrLocalEnum::Class(),(size_t)v9_GlobalOrLocal)));set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcStructuralSurfaceActivityTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcStyleModel
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStyleModel::Class() { return *((IfcParse::entity*)IFC4_types[996]); }
|
|
void Ifc4::IfcStyleModel::initialize(::Ifc4::IfcRepresentationContext v1_ContextOfItems, std::optional< std::string > v2_RepresentationIdentifier, std::optional< std::string > v3_RepresentationType, std::vector< ::Ifc4::IfcRepresentationItem > v4_Items) { set_attribute_value(0, (v1_ContextOfItems)); if (v2_RepresentationIdentifier) {set_attribute_value(1, (*v2_RepresentationIdentifier)); } if (v3_RepresentationType) {set_attribute_value(2, (*v3_RepresentationType)); }set_attribute_value(3, cast_vector<express::Base>(v4_Items)); }
|
|
|
|
// Function implementations for IfcStyledItem
|
|
::Ifc4::IfcRepresentationItem Ifc4::IfcStyledItem::Item() const { if(get_attribute_value(0).isNull()) { return ::Ifc4::IfcRepresentationItem{}; } return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcRepresentationItem>(); }
|
|
void Ifc4::IfcStyledItem::setItem(const ::Ifc4::IfcRepresentationItem& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::vector< ::Ifc4::IfcStyleAssignmentSelect > Ifc4::IfcStyledItem::Styles() const { std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcStyleAssignmentSelect>(es); }
|
|
void Ifc4::IfcStyledItem::setStyles(const std::vector< ::Ifc4::IfcStyleAssignmentSelect >& v) { set_attribute_value(1, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(1); }
|
|
std::optional< std::string > Ifc4::IfcStyledItem::Name() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcStyledItem::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStyledItem::Class() { return *((IfcParse::entity*)IFC4_types[994]); }
|
|
void Ifc4::IfcStyledItem::initialize(::Ifc4::IfcRepresentationItem v1_Item, std::vector< ::Ifc4::IfcStyleAssignmentSelect > v2_Styles, std::optional< std::string > v3_Name) { set_attribute_value(0, (v1_Item));set_attribute_value(1, cast_vector<express::Base>(v2_Styles)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } }
|
|
|
|
// Function implementations for IfcStyledRepresentation
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcStyledRepresentation::Class() { return *((IfcParse::entity*)IFC4_types[995]); }
|
|
void Ifc4::IfcStyledRepresentation::initialize(::Ifc4::IfcRepresentationContext v1_ContextOfItems, std::optional< std::string > v2_RepresentationIdentifier, std::optional< std::string > v3_RepresentationType, std::vector< ::Ifc4::IfcRepresentationItem > v4_Items) { set_attribute_value(0, (v1_ContextOfItems)); if (v2_RepresentationIdentifier) {set_attribute_value(1, (*v2_RepresentationIdentifier)); } if (v3_RepresentationType) {set_attribute_value(2, (*v3_RepresentationType)); }set_attribute_value(3, cast_vector<express::Base>(v4_Items)); }
|
|
|
|
// Function implementations for IfcSubContractResource
|
|
std::optional< ::Ifc4::IfcSubContractResourceTypeEnum::Value > Ifc4::IfcSubContractResource::PredefinedType() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } return ::Ifc4::IfcSubContractResourceTypeEnum::FromString(get_attribute_value(10)); }
|
|
void Ifc4::IfcSubContractResource::setPredefinedType(const std::optional< ::Ifc4::IfcSubContractResourceTypeEnum::Value >& v) { if (v) {set_attribute_value(10, EnumerationReference(&::Ifc4::IfcSubContractResourceTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(10);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSubContractResource::Class() { return *((IfcParse::entity*)IFC4_types[997]); }
|
|
void Ifc4::IfcSubContractResource::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< std::string > v7_LongDescription, ::Ifc4::IfcResourceTime v8_Usage, std::optional< std::vector< ::Ifc4::IfcAppliedValue > > v9_BaseCosts, ::Ifc4::IfcPhysicalQuantity v10_BaseQuantity, std::optional< ::Ifc4::IfcSubContractResourceTypeEnum::Value > v11_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_LongDescription) {set_attribute_value(6, (*v7_LongDescription)); }set_attribute_value(7, (v8_Usage)); if (v9_BaseCosts) {set_attribute_value(8, cast_vector<express::Base>(*v9_BaseCosts)); }set_attribute_value(9, (v10_BaseQuantity)); if (v11_PredefinedType) {set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcSubContractResourceTypeEnum::Class(),(size_t)*v11_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcSubContractResourceType
|
|
::Ifc4::IfcSubContractResourceTypeEnum::Value Ifc4::IfcSubContractResourceType::PredefinedType() const { return ::Ifc4::IfcSubContractResourceTypeEnum::FromString(get_attribute_value(11)); }
|
|
void Ifc4::IfcSubContractResourceType::setPredefinedType(const ::Ifc4::IfcSubContractResourceTypeEnum::Value& v) { set_attribute_value(11, EnumerationReference(&::Ifc4::IfcSubContractResourceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(11); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSubContractResourceType::Class() { return *((IfcParse::entity*)IFC4_types[998]); }
|
|
void Ifc4::IfcSubContractResourceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::string > v7_Identification, std::optional< std::string > v8_LongDescription, std::optional< std::string > v9_ResourceType, std::optional< std::vector< ::Ifc4::IfcAppliedValue > > v10_BaseCosts, ::Ifc4::IfcPhysicalQuantity v11_BaseQuantity, ::Ifc4::IfcSubContractResourceTypeEnum::Value v12_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_Identification) {set_attribute_value(6, (*v7_Identification)); } if (v8_LongDescription) {set_attribute_value(7, (*v8_LongDescription)); } if (v9_ResourceType) {set_attribute_value(8, (*v9_ResourceType)); } if (v10_BaseCosts) {set_attribute_value(9, cast_vector<express::Base>(*v10_BaseCosts)); }set_attribute_value(10, (v11_BaseQuantity));set_attribute_value(11, (EnumerationReference(&::Ifc4::IfcSubContractResourceTypeEnum::Class(),(size_t)v12_PredefinedType))); }
|
|
|
|
// Function implementations for IfcSubedge
|
|
::Ifc4::IfcEdge Ifc4::IfcSubedge::ParentEdge() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcEdge>(); }
|
|
void Ifc4::IfcSubedge::setParentEdge(const ::Ifc4::IfcEdge& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSubedge::Class() { return *((IfcParse::entity*)IFC4_types[1000]); }
|
|
void Ifc4::IfcSubedge::initialize(::Ifc4::IfcVertex v1_EdgeStart, ::Ifc4::IfcVertex v2_EdgeEnd, ::Ifc4::IfcEdge v3_ParentEdge) { set_attribute_value(0, (v1_EdgeStart));set_attribute_value(1, (v2_EdgeEnd));set_attribute_value(2, (v3_ParentEdge)); }
|
|
|
|
// Function implementations for IfcSurface
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSurface::Class() { return *((IfcParse::entity*)IFC4_types[1001]); }
|
|
void Ifc4::IfcSurface::initialize() { }
|
|
|
|
// Function implementations for IfcSurfaceCurve
|
|
::Ifc4::IfcCurve Ifc4::IfcSurfaceCurve::Curve3D() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcCurve>(); }
|
|
void Ifc4::IfcSurfaceCurve::setCurve3D(const ::Ifc4::IfcCurve& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::vector< ::Ifc4::IfcPcurve > Ifc4::IfcSurfaceCurve::AssociatedGeometry() const { std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcPcurve>(es); }
|
|
void Ifc4::IfcSurfaceCurve::setAssociatedGeometry(const std::vector< ::Ifc4::IfcPcurve >& v) { set_attribute_value(1, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcPreferredSurfaceCurveRepresentation::Value Ifc4::IfcSurfaceCurve::MasterRepresentation() const { return ::Ifc4::IfcPreferredSurfaceCurveRepresentation::FromString(get_attribute_value(2)); }
|
|
void Ifc4::IfcSurfaceCurve::setMasterRepresentation(const ::Ifc4::IfcPreferredSurfaceCurveRepresentation::Value& v) { set_attribute_value(2, EnumerationReference(&::Ifc4::IfcPreferredSurfaceCurveRepresentation::Class(), (size_t) v));if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSurfaceCurve::Class() { return *((IfcParse::entity*)IFC4_types[1002]); }
|
|
void Ifc4::IfcSurfaceCurve::initialize(::Ifc4::IfcCurve v1_Curve3D, std::vector< ::Ifc4::IfcPcurve > v2_AssociatedGeometry, ::Ifc4::IfcPreferredSurfaceCurveRepresentation::Value v3_MasterRepresentation) { set_attribute_value(0, (v1_Curve3D));set_attribute_value(1, cast_vector<express::Base>(v2_AssociatedGeometry));set_attribute_value(2, (EnumerationReference(&::Ifc4::IfcPreferredSurfaceCurveRepresentation::Class(),(size_t)v3_MasterRepresentation))); }
|
|
|
|
// Function implementations for IfcSurfaceCurveSweptAreaSolid
|
|
::Ifc4::IfcCurve Ifc4::IfcSurfaceCurveSweptAreaSolid::Directrix() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcCurve>(); }
|
|
void Ifc4::IfcSurfaceCurveSweptAreaSolid::setDirectrix(const ::Ifc4::IfcCurve& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
std::optional< double > Ifc4::IfcSurfaceCurveSweptAreaSolid::StartParam() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcSurfaceCurveSweptAreaSolid::setStartParam(const std::optional< double >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< double > Ifc4::IfcSurfaceCurveSweptAreaSolid::EndParam() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcSurfaceCurveSweptAreaSolid::setEndParam(const std::optional< double >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
::Ifc4::IfcSurface Ifc4::IfcSurfaceCurveSweptAreaSolid::ReferenceSurface() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcSurface>(); }
|
|
void Ifc4::IfcSurfaceCurveSweptAreaSolid::setReferenceSurface(const ::Ifc4::IfcSurface& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSurfaceCurveSweptAreaSolid::Class() { return *((IfcParse::entity*)IFC4_types[1003]); }
|
|
void Ifc4::IfcSurfaceCurveSweptAreaSolid::initialize(::Ifc4::IfcProfileDef v1_SweptArea, ::Ifc4::IfcAxis2Placement3D v2_Position, ::Ifc4::IfcCurve v3_Directrix, std::optional< double > v4_StartParam, std::optional< double > v5_EndParam, ::Ifc4::IfcSurface v6_ReferenceSurface) { set_attribute_value(0, (v1_SweptArea));set_attribute_value(1, (v2_Position));set_attribute_value(2, (v3_Directrix)); if (v4_StartParam) {set_attribute_value(3, (*v4_StartParam)); } if (v5_EndParam) {set_attribute_value(4, (*v5_EndParam)); }set_attribute_value(5, (v6_ReferenceSurface)); }
|
|
|
|
// Function implementations for IfcSurfaceFeature
|
|
std::optional< ::Ifc4::IfcSurfaceFeatureTypeEnum::Value > Ifc4::IfcSurfaceFeature::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcSurfaceFeatureTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcSurfaceFeature::setPredefinedType(const std::optional< ::Ifc4::IfcSurfaceFeatureTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcSurfaceFeatureTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSurfaceFeature::Class() { return *((IfcParse::entity*)IFC4_types[1004]); }
|
|
void Ifc4::IfcSurfaceFeature::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcSurfaceFeatureTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcSurfaceFeatureTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcSurfaceOfLinearExtrusion
|
|
::Ifc4::IfcDirection Ifc4::IfcSurfaceOfLinearExtrusion::ExtrudedDirection() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcDirection>(); }
|
|
void Ifc4::IfcSurfaceOfLinearExtrusion::setExtrudedDirection(const ::Ifc4::IfcDirection& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
double Ifc4::IfcSurfaceOfLinearExtrusion::Depth() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcSurfaceOfLinearExtrusion::setDepth(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSurfaceOfLinearExtrusion::Class() { return *((IfcParse::entity*)IFC4_types[1006]); }
|
|
void Ifc4::IfcSurfaceOfLinearExtrusion::initialize(::Ifc4::IfcProfileDef v1_SweptCurve, ::Ifc4::IfcAxis2Placement3D v2_Position, ::Ifc4::IfcDirection v3_ExtrudedDirection, double v4_Depth) { set_attribute_value(0, (v1_SweptCurve));set_attribute_value(1, (v2_Position));set_attribute_value(2, (v3_ExtrudedDirection));set_attribute_value(3, (v4_Depth)); }
|
|
|
|
// Function implementations for IfcSurfaceOfRevolution
|
|
::Ifc4::IfcAxis1Placement Ifc4::IfcSurfaceOfRevolution::AxisPosition() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcAxis1Placement>(); }
|
|
void Ifc4::IfcSurfaceOfRevolution::setAxisPosition(const ::Ifc4::IfcAxis1Placement& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSurfaceOfRevolution::Class() { return *((IfcParse::entity*)IFC4_types[1007]); }
|
|
void Ifc4::IfcSurfaceOfRevolution::initialize(::Ifc4::IfcProfileDef v1_SweptCurve, ::Ifc4::IfcAxis2Placement3D v2_Position, ::Ifc4::IfcAxis1Placement v3_AxisPosition) { set_attribute_value(0, (v1_SweptCurve));set_attribute_value(1, (v2_Position));set_attribute_value(2, (v3_AxisPosition)); }
|
|
|
|
// Function implementations for IfcSurfaceReinforcementArea
|
|
std::optional< std::vector< double > /*[2:3]*/ > Ifc4::IfcSurfaceReinforcementArea::SurfaceReinforcement1() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::vector< double > /*[2:3]*/ v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcSurfaceReinforcementArea::setSurfaceReinforcement1(const std::optional< std::vector< double > /*[2:3]*/ >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< std::vector< double > /*[2:3]*/ > Ifc4::IfcSurfaceReinforcementArea::SurfaceReinforcement2() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::vector< double > /*[2:3]*/ v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcSurfaceReinforcementArea::setSurfaceReinforcement2(const std::optional< std::vector< double > /*[2:3]*/ >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< double > Ifc4::IfcSurfaceReinforcementArea::ShearReinforcement() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcSurfaceReinforcementArea::setShearReinforcement(const std::optional< double >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSurfaceReinforcementArea::Class() { return *((IfcParse::entity*)IFC4_types[1009]); }
|
|
void Ifc4::IfcSurfaceReinforcementArea::initialize(std::optional< std::string > v1_Name, std::optional< std::vector< double > /*[2:3]*/ > v2_SurfaceReinforcement1, std::optional< std::vector< double > /*[2:3]*/ > v3_SurfaceReinforcement2, std::optional< double > v4_ShearReinforcement) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_SurfaceReinforcement1) {set_attribute_value(1, (*v2_SurfaceReinforcement1)); } if (v3_SurfaceReinforcement2) {set_attribute_value(2, (*v3_SurfaceReinforcement2)); } if (v4_ShearReinforcement) {set_attribute_value(3, (*v4_ShearReinforcement)); } }
|
|
|
|
// Function implementations for IfcSurfaceStyle
|
|
::Ifc4::IfcSurfaceSide::Value Ifc4::IfcSurfaceStyle::Side() const { return ::Ifc4::IfcSurfaceSide::FromString(get_attribute_value(1)); }
|
|
void Ifc4::IfcSurfaceStyle::setSide(const ::Ifc4::IfcSurfaceSide::Value& v) { set_attribute_value(1, EnumerationReference(&::Ifc4::IfcSurfaceSide::Class(), (size_t) v));if constexpr (false)unset_attribute_value(1); }
|
|
std::vector< ::Ifc4::IfcSurfaceStyleElementSelect > Ifc4::IfcSurfaceStyle::Styles() const { std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcSurfaceStyleElementSelect>(es); }
|
|
void Ifc4::IfcSurfaceStyle::setStyles(const std::vector< ::Ifc4::IfcSurfaceStyleElementSelect >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSurfaceStyle::Class() { return *((IfcParse::entity*)IFC4_types[1011]); }
|
|
void Ifc4::IfcSurfaceStyle::initialize(std::optional< std::string > v1_Name, ::Ifc4::IfcSurfaceSide::Value v2_Side, std::vector< ::Ifc4::IfcSurfaceStyleElementSelect > v3_Styles) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (EnumerationReference(&::Ifc4::IfcSurfaceSide::Class(),(size_t)v2_Side)));set_attribute_value(2, cast_vector<express::Base>(v3_Styles)); }
|
|
|
|
// Function implementations for IfcSurfaceStyleLighting
|
|
::Ifc4::IfcColourRgb Ifc4::IfcSurfaceStyleLighting::DiffuseTransmissionColour() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcColourRgb>(); }
|
|
void Ifc4::IfcSurfaceStyleLighting::setDiffuseTransmissionColour(const ::Ifc4::IfcColourRgb& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcColourRgb Ifc4::IfcSurfaceStyleLighting::DiffuseReflectionColour() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcColourRgb>(); }
|
|
void Ifc4::IfcSurfaceStyleLighting::setDiffuseReflectionColour(const ::Ifc4::IfcColourRgb& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcColourRgb Ifc4::IfcSurfaceStyleLighting::TransmissionColour() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcColourRgb>(); }
|
|
void Ifc4::IfcSurfaceStyleLighting::setTransmissionColour(const ::Ifc4::IfcColourRgb& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcColourRgb Ifc4::IfcSurfaceStyleLighting::ReflectanceColour() const { return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcColourRgb>(); }
|
|
void Ifc4::IfcSurfaceStyleLighting::setReflectanceColour(const ::Ifc4::IfcColourRgb& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSurfaceStyleLighting::Class() { return *((IfcParse::entity*)IFC4_types[1013]); }
|
|
void Ifc4::IfcSurfaceStyleLighting::initialize(::Ifc4::IfcColourRgb v1_DiffuseTransmissionColour, ::Ifc4::IfcColourRgb v2_DiffuseReflectionColour, ::Ifc4::IfcColourRgb v3_TransmissionColour, ::Ifc4::IfcColourRgb v4_ReflectanceColour) { set_attribute_value(0, (v1_DiffuseTransmissionColour));set_attribute_value(1, (v2_DiffuseReflectionColour));set_attribute_value(2, (v3_TransmissionColour));set_attribute_value(3, (v4_ReflectanceColour)); }
|
|
|
|
// Function implementations for IfcSurfaceStyleRefraction
|
|
std::optional< double > Ifc4::IfcSurfaceStyleRefraction::RefractionIndex() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } double v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcSurfaceStyleRefraction::setRefractionIndex(const std::optional< double >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< double > Ifc4::IfcSurfaceStyleRefraction::DispersionFactor() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcSurfaceStyleRefraction::setDispersionFactor(const std::optional< double >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSurfaceStyleRefraction::Class() { return *((IfcParse::entity*)IFC4_types[1014]); }
|
|
void Ifc4::IfcSurfaceStyleRefraction::initialize(std::optional< double > v1_RefractionIndex, std::optional< double > v2_DispersionFactor) { if (v1_RefractionIndex) {set_attribute_value(0, (*v1_RefractionIndex)); } if (v2_DispersionFactor) {set_attribute_value(1, (*v2_DispersionFactor)); } }
|
|
|
|
// Function implementations for IfcSurfaceStyleRendering
|
|
::Ifc4::IfcColourOrFactor Ifc4::IfcSurfaceStyleRendering::DiffuseColour() const { if(get_attribute_value(2).isNull()) { return ::Ifc4::IfcColourOrFactor{}; } return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcColourOrFactor>(); }
|
|
void Ifc4::IfcSurfaceStyleRendering::setDiffuseColour(const ::Ifc4::IfcColourOrFactor& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcColourOrFactor Ifc4::IfcSurfaceStyleRendering::TransmissionColour() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcColourOrFactor{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcColourOrFactor>(); }
|
|
void Ifc4::IfcSurfaceStyleRendering::setTransmissionColour(const ::Ifc4::IfcColourOrFactor& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
::Ifc4::IfcColourOrFactor Ifc4::IfcSurfaceStyleRendering::DiffuseTransmissionColour() const { if(get_attribute_value(4).isNull()) { return ::Ifc4::IfcColourOrFactor{}; } return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcColourOrFactor>(); }
|
|
void Ifc4::IfcSurfaceStyleRendering::setDiffuseTransmissionColour(const ::Ifc4::IfcColourOrFactor& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcColourOrFactor Ifc4::IfcSurfaceStyleRendering::ReflectionColour() const { if(get_attribute_value(5).isNull()) { return ::Ifc4::IfcColourOrFactor{}; } return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcColourOrFactor>(); }
|
|
void Ifc4::IfcSurfaceStyleRendering::setReflectionColour(const ::Ifc4::IfcColourOrFactor& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
::Ifc4::IfcColourOrFactor Ifc4::IfcSurfaceStyleRendering::SpecularColour() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcColourOrFactor{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcColourOrFactor>(); }
|
|
void Ifc4::IfcSurfaceStyleRendering::setSpecularColour(const ::Ifc4::IfcColourOrFactor& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
::Ifc4::IfcSpecularHighlightSelect Ifc4::IfcSurfaceStyleRendering::SpecularHighlight() const { if(get_attribute_value(7).isNull()) { return ::Ifc4::IfcSpecularHighlightSelect{}; } return ((express::Base)(get_attribute_value(7))).as<::Ifc4::IfcSpecularHighlightSelect>(); }
|
|
void Ifc4::IfcSurfaceStyleRendering::setSpecularHighlight(const ::Ifc4::IfcSpecularHighlightSelect& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
::Ifc4::IfcReflectanceMethodEnum::Value Ifc4::IfcSurfaceStyleRendering::ReflectanceMethod() const { return ::Ifc4::IfcReflectanceMethodEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcSurfaceStyleRendering::setReflectanceMethod(const ::Ifc4::IfcReflectanceMethodEnum::Value& v) { set_attribute_value(8, EnumerationReference(&::Ifc4::IfcReflectanceMethodEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSurfaceStyleRendering::Class() { return *((IfcParse::entity*)IFC4_types[1015]); }
|
|
void Ifc4::IfcSurfaceStyleRendering::initialize(::Ifc4::IfcColourRgb v1_SurfaceColour, std::optional< double > v2_Transparency, ::Ifc4::IfcColourOrFactor v3_DiffuseColour, ::Ifc4::IfcColourOrFactor v4_TransmissionColour, ::Ifc4::IfcColourOrFactor v5_DiffuseTransmissionColour, ::Ifc4::IfcColourOrFactor v6_ReflectionColour, ::Ifc4::IfcColourOrFactor v7_SpecularColour, ::Ifc4::IfcSpecularHighlightSelect v8_SpecularHighlight, ::Ifc4::IfcReflectanceMethodEnum::Value v9_ReflectanceMethod) { set_attribute_value(0, (v1_SurfaceColour)); if (v2_Transparency) {set_attribute_value(1, (*v2_Transparency)); }set_attribute_value(2, (v3_DiffuseColour));set_attribute_value(3, (v4_TransmissionColour));set_attribute_value(4, (v5_DiffuseTransmissionColour));set_attribute_value(5, (v6_ReflectionColour));set_attribute_value(6, (v7_SpecularColour));set_attribute_value(7, (v8_SpecularHighlight));set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcReflectanceMethodEnum::Class(),(size_t)v9_ReflectanceMethod))); }
|
|
|
|
// Function implementations for IfcSurfaceStyleShading
|
|
::Ifc4::IfcColourRgb Ifc4::IfcSurfaceStyleShading::SurfaceColour() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcColourRgb>(); }
|
|
void Ifc4::IfcSurfaceStyleShading::setSurfaceColour(const ::Ifc4::IfcColourRgb& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< double > Ifc4::IfcSurfaceStyleShading::Transparency() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcSurfaceStyleShading::setTransparency(const std::optional< double >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSurfaceStyleShading::Class() { return *((IfcParse::entity*)IFC4_types[1016]); }
|
|
void Ifc4::IfcSurfaceStyleShading::initialize(::Ifc4::IfcColourRgb v1_SurfaceColour, std::optional< double > v2_Transparency) { set_attribute_value(0, (v1_SurfaceColour)); if (v2_Transparency) {set_attribute_value(1, (*v2_Transparency)); } }
|
|
|
|
// Function implementations for IfcSurfaceStyleWithTextures
|
|
std::vector< ::Ifc4::IfcSurfaceTexture > Ifc4::IfcSurfaceStyleWithTextures::Textures() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcSurfaceTexture>(es); }
|
|
void Ifc4::IfcSurfaceStyleWithTextures::setTextures(const std::vector< ::Ifc4::IfcSurfaceTexture >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSurfaceStyleWithTextures::Class() { return *((IfcParse::entity*)IFC4_types[1017]); }
|
|
void Ifc4::IfcSurfaceStyleWithTextures::initialize(std::vector< ::Ifc4::IfcSurfaceTexture > v1_Textures) { set_attribute_value(0, cast_vector<express::Base>(v1_Textures)); }
|
|
|
|
// Function implementations for IfcSurfaceTexture
|
|
bool Ifc4::IfcSurfaceTexture::RepeatS() const { bool v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcSurfaceTexture::setRepeatS(const bool& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
bool Ifc4::IfcSurfaceTexture::RepeatT() const { bool v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcSurfaceTexture::setRepeatT(const bool& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
std::optional< std::string > Ifc4::IfcSurfaceTexture::Mode() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcSurfaceTexture::setMode(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
::Ifc4::IfcCartesianTransformationOperator2D Ifc4::IfcSurfaceTexture::TextureTransform() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcCartesianTransformationOperator2D{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcCartesianTransformationOperator2D>(); }
|
|
void Ifc4::IfcSurfaceTexture::setTextureTransform(const ::Ifc4::IfcCartesianTransformationOperator2D& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< std::vector< std::string > /*[1:?]*/ > Ifc4::IfcSurfaceTexture::Parameter() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcSurfaceTexture::setParameter(const std::optional< std::vector< std::string > /*[1:?]*/ >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
std::vector<::Ifc4::IfcTextureCoordinate> Ifc4::IfcSurfaceTexture::IsMappedBy() const { return cast_vector<IfcTextureCoordinate>(file()->getInverse(data()->id(), IFC4_types[1066], 0)); }
|
|
std::vector<::Ifc4::IfcSurfaceStyleWithTextures> Ifc4::IfcSurfaceTexture::UsedInStyles() const { return cast_vector<IfcSurfaceStyleWithTextures>(file()->getInverse(data()->id(), IFC4_types[1017], 0)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcSurfaceTexture::Class() { return *((IfcParse::entity*)IFC4_types[1018]); }
|
|
void Ifc4::IfcSurfaceTexture::initialize(bool v1_RepeatS, bool v2_RepeatT, std::optional< std::string > v3_Mode, ::Ifc4::IfcCartesianTransformationOperator2D v4_TextureTransform, std::optional< std::vector< std::string > /*[1:?]*/ > v5_Parameter) { set_attribute_value(0, (v1_RepeatS));set_attribute_value(1, (v2_RepeatT)); if (v3_Mode) {set_attribute_value(2, (*v3_Mode)); }set_attribute_value(3, (v4_TextureTransform)); if (v5_Parameter) {set_attribute_value(4, (*v5_Parameter)); } }
|
|
|
|
// Function implementations for IfcSweptAreaSolid
|
|
::Ifc4::IfcProfileDef Ifc4::IfcSweptAreaSolid::SweptArea() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcProfileDef>(); }
|
|
void Ifc4::IfcSweptAreaSolid::setSweptArea(const ::Ifc4::IfcProfileDef& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcAxis2Placement3D Ifc4::IfcSweptAreaSolid::Position() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcAxis2Placement3D{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcAxis2Placement3D>(); }
|
|
void Ifc4::IfcSweptAreaSolid::setPosition(const ::Ifc4::IfcAxis2Placement3D& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSweptAreaSolid::Class() { return *((IfcParse::entity*)IFC4_types[1019]); }
|
|
void Ifc4::IfcSweptAreaSolid::initialize(::Ifc4::IfcProfileDef v1_SweptArea, ::Ifc4::IfcAxis2Placement3D v2_Position) { set_attribute_value(0, (v1_SweptArea));set_attribute_value(1, (v2_Position)); }
|
|
|
|
// Function implementations for IfcSweptDiskSolid
|
|
::Ifc4::IfcCurve Ifc4::IfcSweptDiskSolid::Directrix() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcCurve>(); }
|
|
void Ifc4::IfcSweptDiskSolid::setDirectrix(const ::Ifc4::IfcCurve& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
double Ifc4::IfcSweptDiskSolid::Radius() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcSweptDiskSolid::setRadius(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
std::optional< double > Ifc4::IfcSweptDiskSolid::InnerRadius() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcSweptDiskSolid::setInnerRadius(const std::optional< double >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< double > Ifc4::IfcSweptDiskSolid::StartParam() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcSweptDiskSolid::setStartParam(const std::optional< double >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< double > Ifc4::IfcSweptDiskSolid::EndParam() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcSweptDiskSolid::setEndParam(const std::optional< double >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSweptDiskSolid::Class() { return *((IfcParse::entity*)IFC4_types[1020]); }
|
|
void Ifc4::IfcSweptDiskSolid::initialize(::Ifc4::IfcCurve v1_Directrix, double v2_Radius, std::optional< double > v3_InnerRadius, std::optional< double > v4_StartParam, std::optional< double > v5_EndParam) { set_attribute_value(0, (v1_Directrix));set_attribute_value(1, (v2_Radius)); if (v3_InnerRadius) {set_attribute_value(2, (*v3_InnerRadius)); } if (v4_StartParam) {set_attribute_value(3, (*v4_StartParam)); } if (v5_EndParam) {set_attribute_value(4, (*v5_EndParam)); } }
|
|
|
|
// Function implementations for IfcSweptDiskSolidPolygonal
|
|
std::optional< double > Ifc4::IfcSweptDiskSolidPolygonal::FilletRadius() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcSweptDiskSolidPolygonal::setFilletRadius(const std::optional< double >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSweptDiskSolidPolygonal::Class() { return *((IfcParse::entity*)IFC4_types[1021]); }
|
|
void Ifc4::IfcSweptDiskSolidPolygonal::initialize(::Ifc4::IfcCurve v1_Directrix, double v2_Radius, std::optional< double > v3_InnerRadius, std::optional< double > v4_StartParam, std::optional< double > v5_EndParam, std::optional< double > v6_FilletRadius) { set_attribute_value(0, (v1_Directrix));set_attribute_value(1, (v2_Radius)); if (v3_InnerRadius) {set_attribute_value(2, (*v3_InnerRadius)); } if (v4_StartParam) {set_attribute_value(3, (*v4_StartParam)); } if (v5_EndParam) {set_attribute_value(4, (*v5_EndParam)); } if (v6_FilletRadius) {set_attribute_value(5, (*v6_FilletRadius)); } }
|
|
|
|
// Function implementations for IfcSweptSurface
|
|
::Ifc4::IfcProfileDef Ifc4::IfcSweptSurface::SweptCurve() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcProfileDef>(); }
|
|
void Ifc4::IfcSweptSurface::setSweptCurve(const ::Ifc4::IfcProfileDef& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcAxis2Placement3D Ifc4::IfcSweptSurface::Position() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcAxis2Placement3D{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcAxis2Placement3D>(); }
|
|
void Ifc4::IfcSweptSurface::setPosition(const ::Ifc4::IfcAxis2Placement3D& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSweptSurface::Class() { return *((IfcParse::entity*)IFC4_types[1022]); }
|
|
void Ifc4::IfcSweptSurface::initialize(::Ifc4::IfcProfileDef v1_SweptCurve, ::Ifc4::IfcAxis2Placement3D v2_Position) { set_attribute_value(0, (v1_SweptCurve));set_attribute_value(1, (v2_Position)); }
|
|
|
|
// Function implementations for IfcSwitchingDevice
|
|
std::optional< ::Ifc4::IfcSwitchingDeviceTypeEnum::Value > Ifc4::IfcSwitchingDevice::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcSwitchingDeviceTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcSwitchingDevice::setPredefinedType(const std::optional< ::Ifc4::IfcSwitchingDeviceTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcSwitchingDeviceTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSwitchingDevice::Class() { return *((IfcParse::entity*)IFC4_types[1023]); }
|
|
void Ifc4::IfcSwitchingDevice::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcSwitchingDeviceTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcSwitchingDeviceTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcSwitchingDeviceType
|
|
::Ifc4::IfcSwitchingDeviceTypeEnum::Value Ifc4::IfcSwitchingDeviceType::PredefinedType() const { return ::Ifc4::IfcSwitchingDeviceTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcSwitchingDeviceType::setPredefinedType(const ::Ifc4::IfcSwitchingDeviceTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcSwitchingDeviceTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSwitchingDeviceType::Class() { return *((IfcParse::entity*)IFC4_types[1024]); }
|
|
void Ifc4::IfcSwitchingDeviceType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcSwitchingDeviceTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcSwitchingDeviceTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcSystem
|
|
|
|
std::vector<::Ifc4::IfcRelServicesBuildings> Ifc4::IfcSystem::ServicesBuildings() const { return cast_vector<IfcRelServicesBuildings>(file()->getInverse(data()->id(), IFC4_types[840], 4)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcSystem::Class() { return *((IfcParse::entity*)IFC4_types[1026]); }
|
|
void Ifc4::IfcSystem::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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)); } }
|
|
|
|
// Function implementations for IfcSystemFurnitureElement
|
|
std::optional< ::Ifc4::IfcSystemFurnitureElementTypeEnum::Value > Ifc4::IfcSystemFurnitureElement::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcSystemFurnitureElementTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcSystemFurnitureElement::setPredefinedType(const std::optional< ::Ifc4::IfcSystemFurnitureElementTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcSystemFurnitureElementTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSystemFurnitureElement::Class() { return *((IfcParse::entity*)IFC4_types[1027]); }
|
|
void Ifc4::IfcSystemFurnitureElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcSystemFurnitureElementTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcSystemFurnitureElementTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcSystemFurnitureElementType
|
|
std::optional< ::Ifc4::IfcSystemFurnitureElementTypeEnum::Value > Ifc4::IfcSystemFurnitureElementType::PredefinedType() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } return ::Ifc4::IfcSystemFurnitureElementTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcSystemFurnitureElementType::setPredefinedType(const std::optional< ::Ifc4::IfcSystemFurnitureElementTypeEnum::Value >& v) { if (v) {set_attribute_value(9, EnumerationReference(&::Ifc4::IfcSystemFurnitureElementTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(9);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcSystemFurnitureElementType::Class() { return *((IfcParse::entity*)IFC4_types[1028]); }
|
|
void Ifc4::IfcSystemFurnitureElementType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, std::optional< ::Ifc4::IfcSystemFurnitureElementTypeEnum::Value > v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); } if (v10_PredefinedType) {set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcSystemFurnitureElementTypeEnum::Class(),(size_t)*v10_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcTShapeProfileDef
|
|
double Ifc4::IfcTShapeProfileDef::Depth() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcTShapeProfileDef::setDepth(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
double Ifc4::IfcTShapeProfileDef::FlangeWidth() const { double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcTShapeProfileDef::setFlangeWidth(const double& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
double Ifc4::IfcTShapeProfileDef::WebThickness() const { double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcTShapeProfileDef::setWebThickness(const double& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
double Ifc4::IfcTShapeProfileDef::FlangeThickness() const { double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcTShapeProfileDef::setFlangeThickness(const double& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
std::optional< double > Ifc4::IfcTShapeProfileDef::FilletRadius() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcTShapeProfileDef::setFilletRadius(const std::optional< double >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< double > Ifc4::IfcTShapeProfileDef::FlangeEdgeRadius() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } double v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcTShapeProfileDef::setFlangeEdgeRadius(const std::optional< double >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
std::optional< double > Ifc4::IfcTShapeProfileDef::WebEdgeRadius() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } double v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcTShapeProfileDef::setWebEdgeRadius(const std::optional< double >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
std::optional< double > Ifc4::IfcTShapeProfileDef::WebSlope() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } double v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcTShapeProfileDef::setWebSlope(const std::optional< double >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::optional< double > Ifc4::IfcTShapeProfileDef::FlangeSlope() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } double v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcTShapeProfileDef::setFlangeSlope(const std::optional< double >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTShapeProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[1102]); }
|
|
void Ifc4::IfcTShapeProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcAxis2Placement2D v3_Position, double v4_Depth, double v5_FlangeWidth, double v6_WebThickness, double v7_FlangeThickness, std::optional< double > v8_FilletRadius, std::optional< double > v9_FlangeEdgeRadius, std::optional< double > v10_WebEdgeRadius, std::optional< double > v11_WebSlope, std::optional< double > v12_FlangeSlope) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Position));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)); } }
|
|
|
|
// Function implementations for IfcTable
|
|
std::optional< std::string > Ifc4::IfcTable::Name() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcTable::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< std::vector< ::Ifc4::IfcTableRow > > Ifc4::IfcTable::Rows() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcTableRow>(es); }
|
|
void Ifc4::IfcTable::setRows(const std::optional< std::vector< ::Ifc4::IfcTableRow > >& v) { if (v) {set_attribute_value(1, cast_vector<express::Base>(*v));} else {unset_attribute_value(1);} }
|
|
std::optional< std::vector< ::Ifc4::IfcTableColumn > > Ifc4::IfcTable::Columns() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcTableColumn>(es); }
|
|
void Ifc4::IfcTable::setColumns(const std::optional< std::vector< ::Ifc4::IfcTableColumn > >& v) { if (v) {set_attribute_value(2, cast_vector<express::Base>(*v));} else {unset_attribute_value(2);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTable::Class() { return *((IfcParse::entity*)IFC4_types[1030]); }
|
|
void Ifc4::IfcTable::initialize(std::optional< std::string > v1_Name, std::optional< std::vector< ::Ifc4::IfcTableRow > > v2_Rows, std::optional< std::vector< ::Ifc4::IfcTableColumn > > v3_Columns) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_Rows) {set_attribute_value(1, cast_vector<express::Base>(*v2_Rows)); } if (v3_Columns) {set_attribute_value(2, cast_vector<express::Base>(*v3_Columns)); } }
|
|
|
|
// Function implementations for IfcTableColumn
|
|
std::optional< std::string > Ifc4::IfcTableColumn::Identifier() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcTableColumn::setIdentifier(const std::optional< std::string >& v) { if (v) {set_attribute_value(0, *v);} else {unset_attribute_value(0);} }
|
|
std::optional< std::string > Ifc4::IfcTableColumn::Name() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcTableColumn::setName(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< std::string > Ifc4::IfcTableColumn::Description() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcTableColumn::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
::Ifc4::IfcUnit Ifc4::IfcTableColumn::Unit() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcUnit{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcUnit>(); }
|
|
void Ifc4::IfcTableColumn::setUnit(const ::Ifc4::IfcUnit& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
::Ifc4::IfcReference Ifc4::IfcTableColumn::ReferencePath() const { if(get_attribute_value(4).isNull()) { return ::Ifc4::IfcReference{}; } return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcReference>(); }
|
|
void Ifc4::IfcTableColumn::setReferencePath(const ::Ifc4::IfcReference& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTableColumn::Class() { return *((IfcParse::entity*)IFC4_types[1031]); }
|
|
void Ifc4::IfcTableColumn::initialize(std::optional< std::string > v1_Identifier, std::optional< std::string > v2_Name, std::optional< std::string > v3_Description, ::Ifc4::IfcUnit v4_Unit, ::Ifc4::IfcReference v5_ReferencePath) { if (v1_Identifier) {set_attribute_value(0, (*v1_Identifier)); } if (v2_Name) {set_attribute_value(1, (*v2_Name)); } if (v3_Description) {set_attribute_value(2, (*v3_Description)); }set_attribute_value(3, (v4_Unit));set_attribute_value(4, (v5_ReferencePath)); }
|
|
|
|
// Function implementations for IfcTableRow
|
|
std::optional< std::vector< ::Ifc4::IfcValue > > Ifc4::IfcTableRow::RowCells() const { if(get_attribute_value(0).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcValue>(es); }
|
|
void Ifc4::IfcTableRow::setRowCells(const std::optional< std::vector< ::Ifc4::IfcValue > >& v) { if (v) {set_attribute_value(0, cast_vector<express::Base>(*v));} else {unset_attribute_value(0);} }
|
|
std::optional< bool > Ifc4::IfcTableRow::IsHeading() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } bool v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcTableRow::setIsHeading(const std::optional< bool >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTableRow::Class() { return *((IfcParse::entity*)IFC4_types[1032]); }
|
|
void Ifc4::IfcTableRow::initialize(std::optional< std::vector< ::Ifc4::IfcValue > > v1_RowCells, std::optional< bool > v2_IsHeading) { if (v1_RowCells) {set_attribute_value(0, cast_vector<express::Base>(*v1_RowCells)); } if (v2_IsHeading) {set_attribute_value(1, (*v2_IsHeading)); } }
|
|
|
|
// Function implementations for IfcTank
|
|
std::optional< ::Ifc4::IfcTankTypeEnum::Value > Ifc4::IfcTank::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcTankTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcTank::setPredefinedType(const std::optional< ::Ifc4::IfcTankTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcTankTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTank::Class() { return *((IfcParse::entity*)IFC4_types[1033]); }
|
|
void Ifc4::IfcTank::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcTankTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcTankTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcTankType
|
|
::Ifc4::IfcTankTypeEnum::Value Ifc4::IfcTankType::PredefinedType() const { return ::Ifc4::IfcTankTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcTankType::setPredefinedType(const ::Ifc4::IfcTankTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcTankTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTankType::Class() { return *((IfcParse::entity*)IFC4_types[1034]); }
|
|
void Ifc4::IfcTankType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcTankTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcTankTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcTask
|
|
std::optional< std::string > Ifc4::IfcTask::Status() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::string v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcTask::setStatus(const std::optional< std::string >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< std::string > Ifc4::IfcTask::WorkMethod() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcTask::setWorkMethod(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
bool Ifc4::IfcTask::IsMilestone() const { bool v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcTask::setIsMilestone(const bool& v) { set_attribute_value(9, v);if constexpr (false)unset_attribute_value(9); }
|
|
std::optional< int > Ifc4::IfcTask::Priority() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } int v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcTask::setPriority(const std::optional< int >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
::Ifc4::IfcTaskTime Ifc4::IfcTask::TaskTime() const { if(get_attribute_value(11).isNull()) { return ::Ifc4::IfcTaskTime{}; } return ((express::Base)(get_attribute_value(11))).as<::Ifc4::IfcTaskTime>(); }
|
|
void Ifc4::IfcTask::setTaskTime(const ::Ifc4::IfcTaskTime& v) { set_attribute_value(11, v);if constexpr (false)unset_attribute_value(11); }
|
|
std::optional< ::Ifc4::IfcTaskTypeEnum::Value > Ifc4::IfcTask::PredefinedType() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } return ::Ifc4::IfcTaskTypeEnum::FromString(get_attribute_value(12)); }
|
|
void Ifc4::IfcTask::setPredefinedType(const std::optional< ::Ifc4::IfcTaskTypeEnum::Value >& v) { if (v) {set_attribute_value(12, EnumerationReference(&::Ifc4::IfcTaskTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(12);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTask::Class() { return *((IfcParse::entity*)IFC4_types[1036]); }
|
|
void Ifc4::IfcTask::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< std::string > v7_LongDescription, std::optional< std::string > v8_Status, std::optional< std::string > v9_WorkMethod, bool v10_IsMilestone, std::optional< int > v11_Priority, ::Ifc4::IfcTaskTime v12_TaskTime, std::optional< ::Ifc4::IfcTaskTypeEnum::Value > v13_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_LongDescription) {set_attribute_value(6, (*v7_LongDescription)); } if (v8_Status) {set_attribute_value(7, (*v8_Status)); } if (v9_WorkMethod) {set_attribute_value(8, (*v9_WorkMethod)); }set_attribute_value(9, (v10_IsMilestone)); if (v11_Priority) {set_attribute_value(10, (*v11_Priority)); }set_attribute_value(11, (v12_TaskTime)); if (v13_PredefinedType) {set_attribute_value(12, (EnumerationReference(&::Ifc4::IfcTaskTypeEnum::Class(),(size_t)*v13_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcTaskTime
|
|
std::optional< ::Ifc4::IfcTaskDurationEnum::Value > Ifc4::IfcTaskTime::DurationType() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } return ::Ifc4::IfcTaskDurationEnum::FromString(get_attribute_value(3)); }
|
|
void Ifc4::IfcTaskTime::setDurationType(const std::optional< ::Ifc4::IfcTaskDurationEnum::Value >& v) { if (v) {set_attribute_value(3, EnumerationReference(&::Ifc4::IfcTaskDurationEnum::Class(), (size_t) *v));} else {unset_attribute_value(3);} }
|
|
std::optional< std::string > Ifc4::IfcTaskTime::ScheduleDuration() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcTaskTime::setScheduleDuration(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcTaskTime::ScheduleStart() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcTaskTime::setScheduleStart(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< std::string > Ifc4::IfcTaskTime::ScheduleFinish() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcTaskTime::setScheduleFinish(const std::optional< std::string >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
std::optional< std::string > Ifc4::IfcTaskTime::EarlyStart() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::string v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcTaskTime::setEarlyStart(const std::optional< std::string >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< std::string > Ifc4::IfcTaskTime::EarlyFinish() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcTaskTime::setEarlyFinish(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
std::optional< std::string > Ifc4::IfcTaskTime::LateStart() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } std::string v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcTaskTime::setLateStart(const std::optional< std::string >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
std::optional< std::string > Ifc4::IfcTaskTime::LateFinish() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } std::string v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcTaskTime::setLateFinish(const std::optional< std::string >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::optional< std::string > Ifc4::IfcTaskTime::FreeFloat() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } std::string v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcTaskTime::setFreeFloat(const std::optional< std::string >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
std::optional< std::string > Ifc4::IfcTaskTime::TotalFloat() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } std::string v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcTaskTime::setTotalFloat(const std::optional< std::string >& v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
|
|
std::optional< bool > Ifc4::IfcTaskTime::IsCritical() const { if(get_attribute_value(13).isNull()) { return std::nullopt; } bool v = get_attribute_value(13); return v; }
|
|
void Ifc4::IfcTaskTime::setIsCritical(const std::optional< bool >& v) { if (v) {set_attribute_value(13, *v);} else {unset_attribute_value(13);} }
|
|
std::optional< std::string > Ifc4::IfcTaskTime::StatusTime() const { if(get_attribute_value(14).isNull()) { return std::nullopt; } std::string v = get_attribute_value(14); return v; }
|
|
void Ifc4::IfcTaskTime::setStatusTime(const std::optional< std::string >& v) { if (v) {set_attribute_value(14, *v);} else {unset_attribute_value(14);} }
|
|
std::optional< std::string > Ifc4::IfcTaskTime::ActualDuration() const { if(get_attribute_value(15).isNull()) { return std::nullopt; } std::string v = get_attribute_value(15); return v; }
|
|
void Ifc4::IfcTaskTime::setActualDuration(const std::optional< std::string >& v) { if (v) {set_attribute_value(15, *v);} else {unset_attribute_value(15);} }
|
|
std::optional< std::string > Ifc4::IfcTaskTime::ActualStart() const { if(get_attribute_value(16).isNull()) { return std::nullopt; } std::string v = get_attribute_value(16); return v; }
|
|
void Ifc4::IfcTaskTime::setActualStart(const std::optional< std::string >& v) { if (v) {set_attribute_value(16, *v);} else {unset_attribute_value(16);} }
|
|
std::optional< std::string > Ifc4::IfcTaskTime::ActualFinish() const { if(get_attribute_value(17).isNull()) { return std::nullopt; } std::string v = get_attribute_value(17); return v; }
|
|
void Ifc4::IfcTaskTime::setActualFinish(const std::optional< std::string >& v) { if (v) {set_attribute_value(17, *v);} else {unset_attribute_value(17);} }
|
|
std::optional< std::string > Ifc4::IfcTaskTime::RemainingTime() const { if(get_attribute_value(18).isNull()) { return std::nullopt; } std::string v = get_attribute_value(18); return v; }
|
|
void Ifc4::IfcTaskTime::setRemainingTime(const std::optional< std::string >& v) { if (v) {set_attribute_value(18, *v);} else {unset_attribute_value(18);} }
|
|
std::optional< double > Ifc4::IfcTaskTime::Completion() const { if(get_attribute_value(19).isNull()) { return std::nullopt; } double v = get_attribute_value(19); return v; }
|
|
void Ifc4::IfcTaskTime::setCompletion(const std::optional< double >& v) { if (v) {set_attribute_value(19, *v);} else {unset_attribute_value(19);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTaskTime::Class() { return *((IfcParse::entity*)IFC4_types[1038]); }
|
|
void Ifc4::IfcTaskTime::initialize(std::optional< std::string > v1_Name, std::optional< ::Ifc4::IfcDataOriginEnum::Value > v2_DataOrigin, std::optional< std::string > v3_UserDefinedDataOrigin, std::optional< ::Ifc4::IfcTaskDurationEnum::Value > v4_DurationType, std::optional< std::string > v5_ScheduleDuration, std::optional< std::string > v6_ScheduleStart, std::optional< std::string > v7_ScheduleFinish, std::optional< std::string > v8_EarlyStart, std::optional< std::string > v9_EarlyFinish, std::optional< std::string > v10_LateStart, std::optional< std::string > v11_LateFinish, std::optional< std::string > v12_FreeFloat, std::optional< std::string > v13_TotalFloat, std::optional< bool > v14_IsCritical, std::optional< std::string > v15_StatusTime, std::optional< std::string > v16_ActualDuration, std::optional< std::string > v17_ActualStart, std::optional< std::string > v18_ActualFinish, std::optional< std::string > v19_RemainingTime, std::optional< double > v20_Completion) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_DataOrigin) {set_attribute_value(1, (EnumerationReference(&::Ifc4::IfcDataOriginEnum::Class(),(size_t)*v2_DataOrigin))); } if (v3_UserDefinedDataOrigin) {set_attribute_value(2, (*v3_UserDefinedDataOrigin)); } if (v4_DurationType) {set_attribute_value(3, (EnumerationReference(&::Ifc4::IfcTaskDurationEnum::Class(),(size_t)*v4_DurationType))); } if (v5_ScheduleDuration) {set_attribute_value(4, (*v5_ScheduleDuration)); } if (v6_ScheduleStart) {set_attribute_value(5, (*v6_ScheduleStart)); } if (v7_ScheduleFinish) {set_attribute_value(6, (*v7_ScheduleFinish)); } if (v8_EarlyStart) {set_attribute_value(7, (*v8_EarlyStart)); } if (v9_EarlyFinish) {set_attribute_value(8, (*v9_EarlyFinish)); } if (v10_LateStart) {set_attribute_value(9, (*v10_LateStart)); } if (v11_LateFinish) {set_attribute_value(10, (*v11_LateFinish)); } if (v12_FreeFloat) {set_attribute_value(11, (*v12_FreeFloat)); } if (v13_TotalFloat) {set_attribute_value(12, (*v13_TotalFloat)); } if (v14_IsCritical) {set_attribute_value(13, (*v14_IsCritical)); } if (v15_StatusTime) {set_attribute_value(14, (*v15_StatusTime)); } if (v16_ActualDuration) {set_attribute_value(15, (*v16_ActualDuration)); } if (v17_ActualStart) {set_attribute_value(16, (*v17_ActualStart)); } if (v18_ActualFinish) {set_attribute_value(17, (*v18_ActualFinish)); } if (v19_RemainingTime) {set_attribute_value(18, (*v19_RemainingTime)); } if (v20_Completion) {set_attribute_value(19, (*v20_Completion)); } }
|
|
|
|
// Function implementations for IfcTaskTimeRecurring
|
|
::Ifc4::IfcRecurrencePattern Ifc4::IfcTaskTimeRecurring::Recurrence() const { return ((express::Base)(get_attribute_value(20))).as<::Ifc4::IfcRecurrencePattern>(); }
|
|
void Ifc4::IfcTaskTimeRecurring::setRecurrence(const ::Ifc4::IfcRecurrencePattern& v) { set_attribute_value(20, v);if constexpr (false)unset_attribute_value(20); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTaskTimeRecurring::Class() { return *((IfcParse::entity*)IFC4_types[1039]); }
|
|
void Ifc4::IfcTaskTimeRecurring::initialize(std::optional< std::string > v1_Name, std::optional< ::Ifc4::IfcDataOriginEnum::Value > v2_DataOrigin, std::optional< std::string > v3_UserDefinedDataOrigin, std::optional< ::Ifc4::IfcTaskDurationEnum::Value > v4_DurationType, std::optional< std::string > v5_ScheduleDuration, std::optional< std::string > v6_ScheduleStart, std::optional< std::string > v7_ScheduleFinish, std::optional< std::string > v8_EarlyStart, std::optional< std::string > v9_EarlyFinish, std::optional< std::string > v10_LateStart, std::optional< std::string > v11_LateFinish, std::optional< std::string > v12_FreeFloat, std::optional< std::string > v13_TotalFloat, std::optional< bool > v14_IsCritical, std::optional< std::string > v15_StatusTime, std::optional< std::string > v16_ActualDuration, std::optional< std::string > v17_ActualStart, std::optional< std::string > v18_ActualFinish, std::optional< std::string > v19_RemainingTime, std::optional< double > v20_Completion, ::Ifc4::IfcRecurrencePattern v21_Recurrence) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_DataOrigin) {set_attribute_value(1, (EnumerationReference(&::Ifc4::IfcDataOriginEnum::Class(),(size_t)*v2_DataOrigin))); } if (v3_UserDefinedDataOrigin) {set_attribute_value(2, (*v3_UserDefinedDataOrigin)); } if (v4_DurationType) {set_attribute_value(3, (EnumerationReference(&::Ifc4::IfcTaskDurationEnum::Class(),(size_t)*v4_DurationType))); } if (v5_ScheduleDuration) {set_attribute_value(4, (*v5_ScheduleDuration)); } if (v6_ScheduleStart) {set_attribute_value(5, (*v6_ScheduleStart)); } if (v7_ScheduleFinish) {set_attribute_value(6, (*v7_ScheduleFinish)); } if (v8_EarlyStart) {set_attribute_value(7, (*v8_EarlyStart)); } if (v9_EarlyFinish) {set_attribute_value(8, (*v9_EarlyFinish)); } if (v10_LateStart) {set_attribute_value(9, (*v10_LateStart)); } if (v11_LateFinish) {set_attribute_value(10, (*v11_LateFinish)); } if (v12_FreeFloat) {set_attribute_value(11, (*v12_FreeFloat)); } if (v13_TotalFloat) {set_attribute_value(12, (*v13_TotalFloat)); } if (v14_IsCritical) {set_attribute_value(13, (*v14_IsCritical)); } if (v15_StatusTime) {set_attribute_value(14, (*v15_StatusTime)); } if (v16_ActualDuration) {set_attribute_value(15, (*v16_ActualDuration)); } if (v17_ActualStart) {set_attribute_value(16, (*v17_ActualStart)); } if (v18_ActualFinish) {set_attribute_value(17, (*v18_ActualFinish)); } if (v19_RemainingTime) {set_attribute_value(18, (*v19_RemainingTime)); } if (v20_Completion) {set_attribute_value(19, (*v20_Completion)); }set_attribute_value(20, (v21_Recurrence)); }
|
|
|
|
// Function implementations for IfcTaskType
|
|
::Ifc4::IfcTaskTypeEnum::Value Ifc4::IfcTaskType::PredefinedType() const { return ::Ifc4::IfcTaskTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcTaskType::setPredefinedType(const ::Ifc4::IfcTaskTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcTaskTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
std::optional< std::string > Ifc4::IfcTaskType::WorkMethod() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } std::string v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcTaskType::setWorkMethod(const std::optional< std::string >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTaskType::Class() { return *((IfcParse::entity*)IFC4_types[1040]); }
|
|
void Ifc4::IfcTaskType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::string > v7_Identification, std::optional< std::string > v8_LongDescription, std::optional< std::string > v9_ProcessType, ::Ifc4::IfcTaskTypeEnum::Value v10_PredefinedType, std::optional< std::string > v11_WorkMethod) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_Identification) {set_attribute_value(6, (*v7_Identification)); } if (v8_LongDescription) {set_attribute_value(7, (*v8_LongDescription)); } if (v9_ProcessType) {set_attribute_value(8, (*v9_ProcessType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcTaskTypeEnum::Class(),(size_t)v10_PredefinedType))); if (v11_WorkMethod) {set_attribute_value(10, (*v11_WorkMethod)); } }
|
|
|
|
// Function implementations for IfcTelecomAddress
|
|
std::optional< std::vector< std::string > /*[1:?]*/ > Ifc4::IfcTelecomAddress::TelephoneNumbers() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcTelecomAddress::setTelephoneNumbers(const std::optional< std::vector< std::string > /*[1:?]*/ >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< std::vector< std::string > /*[1:?]*/ > Ifc4::IfcTelecomAddress::FacsimileNumbers() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcTelecomAddress::setFacsimileNumbers(const std::optional< std::vector< std::string > /*[1:?]*/ >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcTelecomAddress::PagerNumber() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcTelecomAddress::setPagerNumber(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< std::vector< std::string > /*[1:?]*/ > Ifc4::IfcTelecomAddress::ElectronicMailAddresses() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcTelecomAddress::setElectronicMailAddresses(const std::optional< std::vector< std::string > /*[1:?]*/ >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
std::optional< std::string > Ifc4::IfcTelecomAddress::WWWHomePageURL() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::string v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcTelecomAddress::setWWWHomePageURL(const std::optional< std::string >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< std::vector< std::string > /*[1:?]*/ > Ifc4::IfcTelecomAddress::MessagingIDs() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::vector< std::string > /*[1:?]*/ v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcTelecomAddress::setMessagingIDs(const std::optional< std::vector< std::string > /*[1:?]*/ >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTelecomAddress::Class() { return *((IfcParse::entity*)IFC4_types[1042]); }
|
|
void Ifc4::IfcTelecomAddress::initialize(std::optional< ::Ifc4::IfcAddressTypeEnum::Value > v1_Purpose, std::optional< std::string > v2_Description, std::optional< std::string > v3_UserDefinedPurpose, std::optional< std::vector< std::string > /*[1:?]*/ > v4_TelephoneNumbers, std::optional< std::vector< std::string > /*[1:?]*/ > v5_FacsimileNumbers, std::optional< std::string > v6_PagerNumber, std::optional< std::vector< std::string > /*[1:?]*/ > v7_ElectronicMailAddresses, std::optional< std::string > v8_WWWHomePageURL, std::optional< std::vector< std::string > /*[1:?]*/ > v9_MessagingIDs) { if (v1_Purpose) {set_attribute_value(0, (EnumerationReference(&::Ifc4::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)); } if (v9_MessagingIDs) {set_attribute_value(8, (*v9_MessagingIDs)); } }
|
|
|
|
// Function implementations for IfcTendon
|
|
std::optional< ::Ifc4::IfcTendonTypeEnum::Value > Ifc4::IfcTendon::PredefinedType() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } return ::Ifc4::IfcTendonTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcTendon::setPredefinedType(const std::optional< ::Ifc4::IfcTendonTypeEnum::Value >& v) { if (v) {set_attribute_value(9, EnumerationReference(&::Ifc4::IfcTendonTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(9);} }
|
|
std::optional< double > Ifc4::IfcTendon::NominalDiameter() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } double v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcTendon::setNominalDiameter(const std::optional< double >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::optional< double > Ifc4::IfcTendon::CrossSectionArea() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } double v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcTendon::setCrossSectionArea(const std::optional< double >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
std::optional< double > Ifc4::IfcTendon::TensionForce() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } double v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcTendon::setTensionForce(const std::optional< double >& v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
|
|
std::optional< double > Ifc4::IfcTendon::PreStress() const { if(get_attribute_value(13).isNull()) { return std::nullopt; } double v = get_attribute_value(13); return v; }
|
|
void Ifc4::IfcTendon::setPreStress(const std::optional< double >& v) { if (v) {set_attribute_value(13, *v);} else {unset_attribute_value(13);} }
|
|
std::optional< double > Ifc4::IfcTendon::FrictionCoefficient() const { if(get_attribute_value(14).isNull()) { return std::nullopt; } double v = get_attribute_value(14); return v; }
|
|
void Ifc4::IfcTendon::setFrictionCoefficient(const std::optional< double >& v) { if (v) {set_attribute_value(14, *v);} else {unset_attribute_value(14);} }
|
|
std::optional< double > Ifc4::IfcTendon::AnchorageSlip() const { if(get_attribute_value(15).isNull()) { return std::nullopt; } double v = get_attribute_value(15); return v; }
|
|
void Ifc4::IfcTendon::setAnchorageSlip(const std::optional< double >& v) { if (v) {set_attribute_value(15, *v);} else {unset_attribute_value(15);} }
|
|
std::optional< double > Ifc4::IfcTendon::MinCurvatureRadius() const { if(get_attribute_value(16).isNull()) { return std::nullopt; } double v = get_attribute_value(16); return v; }
|
|
void Ifc4::IfcTendon::setMinCurvatureRadius(const std::optional< double >& v) { if (v) {set_attribute_value(16, *v);} else {unset_attribute_value(16);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTendon::Class() { return *((IfcParse::entity*)IFC4_types[1045]); }
|
|
void Ifc4::IfcTendon::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< std::string > v9_SteelGrade, std::optional< ::Ifc4::IfcTendonTypeEnum::Value > v10_PredefinedType, std::optional< double > v11_NominalDiameter, std::optional< double > v12_CrossSectionArea, std::optional< double > v13_TensionForce, std::optional< double > v14_PreStress, std::optional< double > v15_FrictionCoefficient, std::optional< double > v16_AnchorageSlip, std::optional< double > v17_MinCurvatureRadius) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_SteelGrade) {set_attribute_value(8, (*v9_SteelGrade)); } if (v10_PredefinedType) {set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcTendonTypeEnum::Class(),(size_t)*v10_PredefinedType))); } if (v11_NominalDiameter) {set_attribute_value(10, (*v11_NominalDiameter)); } if (v12_CrossSectionArea) {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)); } }
|
|
|
|
// Function implementations for IfcTendonAnchor
|
|
std::optional< ::Ifc4::IfcTendonAnchorTypeEnum::Value > Ifc4::IfcTendonAnchor::PredefinedType() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } return ::Ifc4::IfcTendonAnchorTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcTendonAnchor::setPredefinedType(const std::optional< ::Ifc4::IfcTendonAnchorTypeEnum::Value >& v) { if (v) {set_attribute_value(9, EnumerationReference(&::Ifc4::IfcTendonAnchorTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(9);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTendonAnchor::Class() { return *((IfcParse::entity*)IFC4_types[1046]); }
|
|
void Ifc4::IfcTendonAnchor::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< std::string > v9_SteelGrade, std::optional< ::Ifc4::IfcTendonAnchorTypeEnum::Value > v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_SteelGrade) {set_attribute_value(8, (*v9_SteelGrade)); } if (v10_PredefinedType) {set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcTendonAnchorTypeEnum::Class(),(size_t)*v10_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcTendonAnchorType
|
|
::Ifc4::IfcTendonAnchorTypeEnum::Value Ifc4::IfcTendonAnchorType::PredefinedType() const { return ::Ifc4::IfcTendonAnchorTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcTendonAnchorType::setPredefinedType(const ::Ifc4::IfcTendonAnchorTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcTendonAnchorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTendonAnchorType::Class() { return *((IfcParse::entity*)IFC4_types[1047]); }
|
|
void Ifc4::IfcTendonAnchorType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcTendonAnchorTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcTendonAnchorTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcTendonType
|
|
::Ifc4::IfcTendonTypeEnum::Value Ifc4::IfcTendonType::PredefinedType() const { return ::Ifc4::IfcTendonTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcTendonType::setPredefinedType(const ::Ifc4::IfcTendonTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcTendonTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
std::optional< double > Ifc4::IfcTendonType::NominalDiameter() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } double v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcTendonType::setNominalDiameter(const std::optional< double >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::optional< double > Ifc4::IfcTendonType::CrossSectionArea() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } double v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcTendonType::setCrossSectionArea(const std::optional< double >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
std::optional< double > Ifc4::IfcTendonType::SheathDiameter() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } double v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcTendonType::setSheathDiameter(const std::optional< double >& v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTendonType::Class() { return *((IfcParse::entity*)IFC4_types[1049]); }
|
|
void Ifc4::IfcTendonType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcTendonTypeEnum::Value v10_PredefinedType, std::optional< double > v11_NominalDiameter, std::optional< double > v12_CrossSectionArea, std::optional< double > v13_SheathDiameter) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcTendonTypeEnum::Class(),(size_t)v10_PredefinedType))); if (v11_NominalDiameter) {set_attribute_value(10, (*v11_NominalDiameter)); } if (v12_CrossSectionArea) {set_attribute_value(11, (*v12_CrossSectionArea)); } if (v13_SheathDiameter) {set_attribute_value(12, (*v13_SheathDiameter)); } }
|
|
|
|
// Function implementations for IfcTessellatedFaceSet
|
|
::Ifc4::IfcCartesianPointList3D Ifc4::IfcTessellatedFaceSet::Coordinates() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcCartesianPointList3D>(); }
|
|
void Ifc4::IfcTessellatedFaceSet::setCoordinates(const ::Ifc4::IfcCartesianPointList3D& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
std::vector<::Ifc4::IfcIndexedColourMap> Ifc4::IfcTessellatedFaceSet::HasColours() const { return cast_vector<IfcIndexedColourMap>(file()->getInverse(data()->id(), IFC4_types[479], 0)); }
|
|
std::vector<::Ifc4::IfcIndexedTextureMap> Ifc4::IfcTessellatedFaceSet::HasTextures() const { return cast_vector<IfcIndexedTextureMap>(file()->getInverse(data()->id(), IFC4_types[483], 1)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcTessellatedFaceSet::Class() { return *((IfcParse::entity*)IFC4_types[1051]); }
|
|
void Ifc4::IfcTessellatedFaceSet::initialize(::Ifc4::IfcCartesianPointList3D v1_Coordinates) { set_attribute_value(0, (v1_Coordinates)); }
|
|
|
|
// Function implementations for IfcTessellatedItem
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTessellatedItem::Class() { return *((IfcParse::entity*)IFC4_types[1052]); }
|
|
void Ifc4::IfcTessellatedItem::initialize() { }
|
|
|
|
// Function implementations for IfcTextLiteral
|
|
std::string Ifc4::IfcTextLiteral::Literal() const { std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcTextLiteral::setLiteral(const std::string& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcAxis2Placement Ifc4::IfcTextLiteral::Placement() const { return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcAxis2Placement>(); }
|
|
void Ifc4::IfcTextLiteral::setPlacement(const ::Ifc4::IfcAxis2Placement& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcTextPath::Value Ifc4::IfcTextLiteral::Path() const { return ::Ifc4::IfcTextPath::FromString(get_attribute_value(2)); }
|
|
void Ifc4::IfcTextLiteral::setPath(const ::Ifc4::IfcTextPath::Value& v) { set_attribute_value(2, EnumerationReference(&::Ifc4::IfcTextPath::Class(), (size_t) v));if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTextLiteral::Class() { return *((IfcParse::entity*)IFC4_types[1058]); }
|
|
void Ifc4::IfcTextLiteral::initialize(std::string v1_Literal, ::Ifc4::IfcAxis2Placement v2_Placement, ::Ifc4::IfcTextPath::Value v3_Path) { set_attribute_value(0, (v1_Literal));set_attribute_value(1, (v2_Placement));set_attribute_value(2, (EnumerationReference(&::Ifc4::IfcTextPath::Class(),(size_t)v3_Path))); }
|
|
|
|
// Function implementations for IfcTextLiteralWithExtent
|
|
::Ifc4::IfcPlanarExtent Ifc4::IfcTextLiteralWithExtent::Extent() const { return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcPlanarExtent>(); }
|
|
void Ifc4::IfcTextLiteralWithExtent::setExtent(const ::Ifc4::IfcPlanarExtent& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::string Ifc4::IfcTextLiteralWithExtent::BoxAlignment() const { std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcTextLiteralWithExtent::setBoxAlignment(const std::string& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTextLiteralWithExtent::Class() { return *((IfcParse::entity*)IFC4_types[1059]); }
|
|
void Ifc4::IfcTextLiteralWithExtent::initialize(std::string v1_Literal, ::Ifc4::IfcAxis2Placement v2_Placement, ::Ifc4::IfcTextPath::Value v3_Path, ::Ifc4::IfcPlanarExtent v4_Extent, std::string v5_BoxAlignment) { set_attribute_value(0, (v1_Literal));set_attribute_value(1, (v2_Placement));set_attribute_value(2, (EnumerationReference(&::Ifc4::IfcTextPath::Class(),(size_t)v3_Path)));set_attribute_value(3, (v4_Extent));set_attribute_value(4, (v5_BoxAlignment)); }
|
|
|
|
// Function implementations for IfcTextStyle
|
|
::Ifc4::IfcTextStyleForDefinedFont Ifc4::IfcTextStyle::TextCharacterAppearance() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcTextStyleForDefinedFont{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcTextStyleForDefinedFont>(); }
|
|
void Ifc4::IfcTextStyle::setTextCharacterAppearance(const ::Ifc4::IfcTextStyleForDefinedFont& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcTextStyleTextModel Ifc4::IfcTextStyle::TextStyle() const { if(get_attribute_value(2).isNull()) { return ::Ifc4::IfcTextStyleTextModel{}; } return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcTextStyleTextModel>(); }
|
|
void Ifc4::IfcTextStyle::setTextStyle(const ::Ifc4::IfcTextStyleTextModel& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
::Ifc4::IfcTextFontSelect Ifc4::IfcTextStyle::TextFontStyle() const { return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcTextFontSelect>(); }
|
|
void Ifc4::IfcTextStyle::setTextFontStyle(const ::Ifc4::IfcTextFontSelect& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< bool > Ifc4::IfcTextStyle::ModelOrDraughting() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } bool v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcTextStyle::setModelOrDraughting(const std::optional< bool >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTextStyle::Class() { return *((IfcParse::entity*)IFC4_types[1061]); }
|
|
void Ifc4::IfcTextStyle::initialize(std::optional< std::string > v1_Name, ::Ifc4::IfcTextStyleForDefinedFont v2_TextCharacterAppearance, ::Ifc4::IfcTextStyleTextModel v3_TextStyle, ::Ifc4::IfcTextFontSelect v4_TextFontStyle, std::optional< bool > v5_ModelOrDraughting) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); }set_attribute_value(1, (v2_TextCharacterAppearance));set_attribute_value(2, (v3_TextStyle));set_attribute_value(3, (v4_TextFontStyle)); if (v5_ModelOrDraughting) {set_attribute_value(4, (*v5_ModelOrDraughting)); } }
|
|
|
|
// Function implementations for IfcTextStyleFontModel
|
|
std::vector< std::string > /*[1:?]*/ Ifc4::IfcTextStyleFontModel::FontFamily() const { std::vector< std::string > /*[1:?]*/ v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcTextStyleFontModel::setFontFamily(const std::vector< std::string > /*[1:?]*/& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
std::optional< std::string > Ifc4::IfcTextStyleFontModel::FontStyle() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcTextStyleFontModel::setFontStyle(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::optional< std::string > Ifc4::IfcTextStyleFontModel::FontVariant() const { if(get_attribute_value(3).isNull()) { return std::nullopt; } std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcTextStyleFontModel::setFontVariant(const std::optional< std::string >& v) { if (v) {set_attribute_value(3, *v);} else {unset_attribute_value(3);} }
|
|
std::optional< std::string > Ifc4::IfcTextStyleFontModel::FontWeight() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcTextStyleFontModel::setFontWeight(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
::Ifc4::IfcSizeSelect Ifc4::IfcTextStyleFontModel::FontSize() const { return ((express::Base)(get_attribute_value(5))).as<::Ifc4::IfcSizeSelect>(); }
|
|
void Ifc4::IfcTextStyleFontModel::setFontSize(const ::Ifc4::IfcSizeSelect& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTextStyleFontModel::Class() { return *((IfcParse::entity*)IFC4_types[1062]); }
|
|
void Ifc4::IfcTextStyleFontModel::initialize(std::string v1_Name, std::vector< std::string > /*[1:?]*/ v2_FontFamily, std::optional< std::string > v3_FontStyle, std::optional< std::string > v4_FontVariant, std::optional< std::string > v5_FontWeight, ::Ifc4::IfcSizeSelect v6_FontSize) { set_attribute_value(0, (v1_Name));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)); }
|
|
|
|
// Function implementations for IfcTextStyleForDefinedFont
|
|
::Ifc4::IfcColour Ifc4::IfcTextStyleForDefinedFont::Colour() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcColour>(); }
|
|
void Ifc4::IfcTextStyleForDefinedFont::setColour(const ::Ifc4::IfcColour& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
::Ifc4::IfcColour Ifc4::IfcTextStyleForDefinedFont::BackgroundColour() const { if(get_attribute_value(1).isNull()) { return ::Ifc4::IfcColour{}; } return ((express::Base)(get_attribute_value(1))).as<::Ifc4::IfcColour>(); }
|
|
void Ifc4::IfcTextStyleForDefinedFont::setBackgroundColour(const ::Ifc4::IfcColour& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTextStyleForDefinedFont::Class() { return *((IfcParse::entity*)IFC4_types[1063]); }
|
|
void Ifc4::IfcTextStyleForDefinedFont::initialize(::Ifc4::IfcColour v1_Colour, ::Ifc4::IfcColour v2_BackgroundColour) { set_attribute_value(0, (v1_Colour));set_attribute_value(1, (v2_BackgroundColour)); }
|
|
|
|
// Function implementations for IfcTextStyleTextModel
|
|
::Ifc4::IfcSizeSelect Ifc4::IfcTextStyleTextModel::TextIndent() const { if(get_attribute_value(0).isNull()) { return ::Ifc4::IfcSizeSelect{}; } return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcSizeSelect>(); }
|
|
void Ifc4::IfcTextStyleTextModel::setTextIndent(const ::Ifc4::IfcSizeSelect& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< std::string > Ifc4::IfcTextStyleTextModel::TextAlign() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcTextStyleTextModel::setTextAlign(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< std::string > Ifc4::IfcTextStyleTextModel::TextDecoration() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcTextStyleTextModel::setTextDecoration(const std::optional< std::string >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
::Ifc4::IfcSizeSelect Ifc4::IfcTextStyleTextModel::LetterSpacing() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcSizeSelect{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcSizeSelect>(); }
|
|
void Ifc4::IfcTextStyleTextModel::setLetterSpacing(const ::Ifc4::IfcSizeSelect& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
::Ifc4::IfcSizeSelect Ifc4::IfcTextStyleTextModel::WordSpacing() const { if(get_attribute_value(4).isNull()) { return ::Ifc4::IfcSizeSelect{}; } return ((express::Base)(get_attribute_value(4))).as<::Ifc4::IfcSizeSelect>(); }
|
|
void Ifc4::IfcTextStyleTextModel::setWordSpacing(const ::Ifc4::IfcSizeSelect& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
std::optional< std::string > Ifc4::IfcTextStyleTextModel::TextTransform() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcTextStyleTextModel::setTextTransform(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
::Ifc4::IfcSizeSelect Ifc4::IfcTextStyleTextModel::LineHeight() const { if(get_attribute_value(6).isNull()) { return ::Ifc4::IfcSizeSelect{}; } return ((express::Base)(get_attribute_value(6))).as<::Ifc4::IfcSizeSelect>(); }
|
|
void Ifc4::IfcTextStyleTextModel::setLineHeight(const ::Ifc4::IfcSizeSelect& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTextStyleTextModel::Class() { return *((IfcParse::entity*)IFC4_types[1064]); }
|
|
void Ifc4::IfcTextStyleTextModel::initialize(::Ifc4::IfcSizeSelect v1_TextIndent, std::optional< std::string > v2_TextAlign, std::optional< std::string > v3_TextDecoration, ::Ifc4::IfcSizeSelect v4_LetterSpacing, ::Ifc4::IfcSizeSelect v5_WordSpacing, std::optional< std::string > v6_TextTransform, ::Ifc4::IfcSizeSelect v7_LineHeight) { set_attribute_value(0, (v1_TextIndent)); if (v2_TextAlign) {set_attribute_value(1, (*v2_TextAlign)); } if (v3_TextDecoration) {set_attribute_value(2, (*v3_TextDecoration)); }set_attribute_value(3, (v4_LetterSpacing));set_attribute_value(4, (v5_WordSpacing)); if (v6_TextTransform) {set_attribute_value(5, (*v6_TextTransform)); }set_attribute_value(6, (v7_LineHeight)); }
|
|
|
|
// Function implementations for IfcTextureCoordinate
|
|
std::vector< ::Ifc4::IfcSurfaceTexture > Ifc4::IfcTextureCoordinate::Maps() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcSurfaceTexture>(es); }
|
|
void Ifc4::IfcTextureCoordinate::setMaps(const std::vector< ::Ifc4::IfcSurfaceTexture >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTextureCoordinate::Class() { return *((IfcParse::entity*)IFC4_types[1066]); }
|
|
void Ifc4::IfcTextureCoordinate::initialize(std::vector< ::Ifc4::IfcSurfaceTexture > v1_Maps) { set_attribute_value(0, cast_vector<express::Base>(v1_Maps)); }
|
|
|
|
// Function implementations for IfcTextureCoordinateGenerator
|
|
std::string Ifc4::IfcTextureCoordinateGenerator::Mode() const { std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcTextureCoordinateGenerator::setMode(const std::string& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
std::optional< std::vector< double > /*[1:?]*/ > Ifc4::IfcTextureCoordinateGenerator::Parameter() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } std::vector< double > /*[1:?]*/ v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcTextureCoordinateGenerator::setParameter(const std::optional< std::vector< double > /*[1:?]*/ >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTextureCoordinateGenerator::Class() { return *((IfcParse::entity*)IFC4_types[1067]); }
|
|
void Ifc4::IfcTextureCoordinateGenerator::initialize(std::vector< ::Ifc4::IfcSurfaceTexture > v1_Maps, std::string v2_Mode, std::optional< std::vector< double > /*[1:?]*/ > v3_Parameter) { set_attribute_value(0, cast_vector<express::Base>(v1_Maps));set_attribute_value(1, (v2_Mode)); if (v3_Parameter) {set_attribute_value(2, (*v3_Parameter)); } }
|
|
|
|
// Function implementations for IfcTextureMap
|
|
std::vector< ::Ifc4::IfcTextureVertex > Ifc4::IfcTextureMap::Vertices() const { std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcTextureVertex>(es); }
|
|
void Ifc4::IfcTextureMap::setVertices(const std::vector< ::Ifc4::IfcTextureVertex >& v) { set_attribute_value(1, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(1); }
|
|
::Ifc4::IfcFace Ifc4::IfcTextureMap::MappedTo() const { return ((express::Base)(get_attribute_value(2))).as<::Ifc4::IfcFace>(); }
|
|
void Ifc4::IfcTextureMap::setMappedTo(const ::Ifc4::IfcFace& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTextureMap::Class() { return *((IfcParse::entity*)IFC4_types[1068]); }
|
|
void Ifc4::IfcTextureMap::initialize(std::vector< ::Ifc4::IfcSurfaceTexture > v1_Maps, std::vector< ::Ifc4::IfcTextureVertex > v2_Vertices, ::Ifc4::IfcFace v3_MappedTo) { set_attribute_value(0, cast_vector<express::Base>(v1_Maps));set_attribute_value(1, cast_vector<express::Base>(v2_Vertices));set_attribute_value(2, (v3_MappedTo)); }
|
|
|
|
// Function implementations for IfcTextureVertex
|
|
std::vector< double > /*[2:2]*/ Ifc4::IfcTextureVertex::Coordinates() const { std::vector< double > /*[2:2]*/ v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcTextureVertex::setCoordinates(const std::vector< double > /*[2:2]*/& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTextureVertex::Class() { return *((IfcParse::entity*)IFC4_types[1069]); }
|
|
void Ifc4::IfcTextureVertex::initialize(std::vector< double > /*[2:2]*/ v1_Coordinates) { set_attribute_value(0, (v1_Coordinates)); }
|
|
|
|
// Function implementations for IfcTextureVertexList
|
|
std::vector< std::vector< double > > Ifc4::IfcTextureVertexList::TexCoordsList() const { std::vector< std::vector< double > > v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcTextureVertexList::setTexCoordsList(const std::vector< std::vector< double > >& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTextureVertexList::Class() { return *((IfcParse::entity*)IFC4_types[1070]); }
|
|
void Ifc4::IfcTextureVertexList::initialize(std::vector< std::vector< double > > v1_TexCoordsList) { set_attribute_value(0, (v1_TexCoordsList)); }
|
|
|
|
// Function implementations for IfcTimePeriod
|
|
std::string Ifc4::IfcTimePeriod::StartTime() const { std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcTimePeriod::setStartTime(const std::string& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::string Ifc4::IfcTimePeriod::EndTime() const { std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcTimePeriod::setEndTime(const std::string& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTimePeriod::Class() { return *((IfcParse::entity*)IFC4_types[1080]); }
|
|
void Ifc4::IfcTimePeriod::initialize(std::string v1_StartTime, std::string v2_EndTime) { set_attribute_value(0, (v1_StartTime));set_attribute_value(1, (v2_EndTime)); }
|
|
|
|
// Function implementations for IfcTimeSeries
|
|
std::string Ifc4::IfcTimeSeries::Name() const { std::string v = get_attribute_value(0); return v; }
|
|
void Ifc4::IfcTimeSeries::setName(const std::string& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::optional< std::string > Ifc4::IfcTimeSeries::Description() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::string v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcTimeSeries::setDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::string Ifc4::IfcTimeSeries::StartTime() const { std::string v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcTimeSeries::setStartTime(const std::string& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
std::string Ifc4::IfcTimeSeries::EndTime() const { std::string v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcTimeSeries::setEndTime(const std::string& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
::Ifc4::IfcTimeSeriesDataTypeEnum::Value Ifc4::IfcTimeSeries::TimeSeriesDataType() const { return ::Ifc4::IfcTimeSeriesDataTypeEnum::FromString(get_attribute_value(4)); }
|
|
void Ifc4::IfcTimeSeries::setTimeSeriesDataType(const ::Ifc4::IfcTimeSeriesDataTypeEnum::Value& v) { set_attribute_value(4, EnumerationReference(&::Ifc4::IfcTimeSeriesDataTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcDataOriginEnum::Value Ifc4::IfcTimeSeries::DataOrigin() const { return ::Ifc4::IfcDataOriginEnum::FromString(get_attribute_value(5)); }
|
|
void Ifc4::IfcTimeSeries::setDataOrigin(const ::Ifc4::IfcDataOriginEnum::Value& v) { set_attribute_value(5, EnumerationReference(&::Ifc4::IfcDataOriginEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(5); }
|
|
std::optional< std::string > Ifc4::IfcTimeSeries::UserDefinedDataOrigin() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcTimeSeries::setUserDefinedDataOrigin(const std::optional< std::string >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
::Ifc4::IfcUnit Ifc4::IfcTimeSeries::Unit() const { if(get_attribute_value(7).isNull()) { return ::Ifc4::IfcUnit{}; } return ((express::Base)(get_attribute_value(7))).as<::Ifc4::IfcUnit>(); }
|
|
void Ifc4::IfcTimeSeries::setUnit(const ::Ifc4::IfcUnit& v) { set_attribute_value(7, v);if constexpr (false)unset_attribute_value(7); }
|
|
|
|
std::vector<::Ifc4::IfcExternalReferenceRelationship> Ifc4::IfcTimeSeries::HasExternalReference() const { return cast_vector<IfcExternalReferenceRelationship>(file()->getInverse(data()->id(), IFC4_types[380], 3)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcTimeSeries::Class() { return *((IfcParse::entity*)IFC4_types[1081]); }
|
|
void Ifc4::IfcTimeSeries::initialize(std::string v1_Name, std::optional< std::string > v2_Description, std::string v3_StartTime, std::string v4_EndTime, ::Ifc4::IfcTimeSeriesDataTypeEnum::Value v5_TimeSeriesDataType, ::Ifc4::IfcDataOriginEnum::Value v6_DataOrigin, std::optional< std::string > v7_UserDefinedDataOrigin, ::Ifc4::IfcUnit v8_Unit) { set_attribute_value(0, (v1_Name)); if (v2_Description) {set_attribute_value(1, (*v2_Description)); }set_attribute_value(2, (v3_StartTime));set_attribute_value(3, (v4_EndTime));set_attribute_value(4, (EnumerationReference(&::Ifc4::IfcTimeSeriesDataTypeEnum::Class(),(size_t)v5_TimeSeriesDataType)));set_attribute_value(5, (EnumerationReference(&::Ifc4::IfcDataOriginEnum::Class(),(size_t)v6_DataOrigin))); if (v7_UserDefinedDataOrigin) {set_attribute_value(6, (*v7_UserDefinedDataOrigin)); }set_attribute_value(7, (v8_Unit)); }
|
|
|
|
// Function implementations for IfcTimeSeriesValue
|
|
std::vector< ::Ifc4::IfcValue > Ifc4::IfcTimeSeriesValue::ListValues() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcValue>(es); }
|
|
void Ifc4::IfcTimeSeriesValue::setListValues(const std::vector< ::Ifc4::IfcValue >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTimeSeriesValue::Class() { return *((IfcParse::entity*)IFC4_types[1083]); }
|
|
void Ifc4::IfcTimeSeriesValue::initialize(std::vector< ::Ifc4::IfcValue > v1_ListValues) { set_attribute_value(0, cast_vector<express::Base>(v1_ListValues)); }
|
|
|
|
// Function implementations for IfcTopologicalRepresentationItem
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTopologicalRepresentationItem::Class() { return *((IfcParse::entity*)IFC4_types[1085]); }
|
|
void Ifc4::IfcTopologicalRepresentationItem::initialize() { }
|
|
|
|
// Function implementations for IfcTopologyRepresentation
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTopologyRepresentation::Class() { return *((IfcParse::entity*)IFC4_types[1086]); }
|
|
void Ifc4::IfcTopologyRepresentation::initialize(::Ifc4::IfcRepresentationContext v1_ContextOfItems, std::optional< std::string > v2_RepresentationIdentifier, std::optional< std::string > v3_RepresentationType, std::vector< ::Ifc4::IfcRepresentationItem > v4_Items) { set_attribute_value(0, (v1_ContextOfItems)); if (v2_RepresentationIdentifier) {set_attribute_value(1, (*v2_RepresentationIdentifier)); } if (v3_RepresentationType) {set_attribute_value(2, (*v3_RepresentationType)); }set_attribute_value(3, cast_vector<express::Base>(v4_Items)); }
|
|
|
|
// Function implementations for IfcToroidalSurface
|
|
double Ifc4::IfcToroidalSurface::MajorRadius() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcToroidalSurface::setMajorRadius(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
double Ifc4::IfcToroidalSurface::MinorRadius() const { double v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcToroidalSurface::setMinorRadius(const double& v) { set_attribute_value(2, v);if constexpr (false)unset_attribute_value(2); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcToroidalSurface::Class() { return *((IfcParse::entity*)IFC4_types[1087]); }
|
|
void Ifc4::IfcToroidalSurface::initialize(::Ifc4::IfcAxis2Placement3D v1_Position, double v2_MajorRadius, double v3_MinorRadius) { set_attribute_value(0, (v1_Position));set_attribute_value(1, (v2_MajorRadius));set_attribute_value(2, (v3_MinorRadius)); }
|
|
|
|
// Function implementations for IfcTransformer
|
|
std::optional< ::Ifc4::IfcTransformerTypeEnum::Value > Ifc4::IfcTransformer::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcTransformerTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcTransformer::setPredefinedType(const std::optional< ::Ifc4::IfcTransformerTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcTransformerTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTransformer::Class() { return *((IfcParse::entity*)IFC4_types[1089]); }
|
|
void Ifc4::IfcTransformer::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcTransformerTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcTransformerTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcTransformerType
|
|
::Ifc4::IfcTransformerTypeEnum::Value Ifc4::IfcTransformerType::PredefinedType() const { return ::Ifc4::IfcTransformerTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcTransformerType::setPredefinedType(const ::Ifc4::IfcTransformerTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcTransformerTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTransformerType::Class() { return *((IfcParse::entity*)IFC4_types[1090]); }
|
|
void Ifc4::IfcTransformerType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcTransformerTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcTransformerTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcTransportElement
|
|
std::optional< ::Ifc4::IfcTransportElementTypeEnum::Value > Ifc4::IfcTransportElement::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcTransportElementTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcTransportElement::setPredefinedType(const std::optional< ::Ifc4::IfcTransportElementTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcTransportElementTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTransportElement::Class() { return *((IfcParse::entity*)IFC4_types[1094]); }
|
|
void Ifc4::IfcTransportElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcTransportElementTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcTransportElementTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcTransportElementType
|
|
::Ifc4::IfcTransportElementTypeEnum::Value Ifc4::IfcTransportElementType::PredefinedType() const { return ::Ifc4::IfcTransportElementTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcTransportElementType::setPredefinedType(const ::Ifc4::IfcTransportElementTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcTransportElementTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTransportElementType::Class() { return *((IfcParse::entity*)IFC4_types[1095]); }
|
|
void Ifc4::IfcTransportElementType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcTransportElementTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcTransportElementTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcTrapeziumProfileDef
|
|
double Ifc4::IfcTrapeziumProfileDef::BottomXDim() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcTrapeziumProfileDef::setBottomXDim(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
double Ifc4::IfcTrapeziumProfileDef::TopXDim() const { double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcTrapeziumProfileDef::setTopXDim(const double& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
double Ifc4::IfcTrapeziumProfileDef::YDim() const { double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcTrapeziumProfileDef::setYDim(const double& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
double Ifc4::IfcTrapeziumProfileDef::TopXOffset() const { double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcTrapeziumProfileDef::setTopXOffset(const double& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTrapeziumProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[1097]); }
|
|
void Ifc4::IfcTrapeziumProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcAxis2Placement2D v3_Position, double v4_BottomXDim, double v5_TopXDim, double v6_YDim, double v7_TopXOffset) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Position));set_attribute_value(3, (v4_BottomXDim));set_attribute_value(4, (v5_TopXDim));set_attribute_value(5, (v6_YDim));set_attribute_value(6, (v7_TopXOffset)); }
|
|
|
|
// Function implementations for IfcTriangulatedFaceSet
|
|
std::optional< std::vector< std::vector< double > > > Ifc4::IfcTriangulatedFaceSet::Normals() const { if(get_attribute_value(1).isNull()) { return std::nullopt; } std::vector< std::vector< double > > v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcTriangulatedFaceSet::setNormals(const std::optional< std::vector< std::vector< double > > >& v) { if (v) {set_attribute_value(1, *v);} else {unset_attribute_value(1);} }
|
|
std::optional< bool > Ifc4::IfcTriangulatedFaceSet::Closed() const { if(get_attribute_value(2).isNull()) { return std::nullopt; } bool v = get_attribute_value(2); return v; }
|
|
void Ifc4::IfcTriangulatedFaceSet::setClosed(const std::optional< bool >& v) { if (v) {set_attribute_value(2, *v);} else {unset_attribute_value(2);} }
|
|
std::vector< std::vector< int > > Ifc4::IfcTriangulatedFaceSet::CoordIndex() const { std::vector< std::vector< int > > v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcTriangulatedFaceSet::setCoordIndex(const std::vector< std::vector< int > >& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< std::vector< int > /*[1:?]*/ > Ifc4::IfcTriangulatedFaceSet::PnIndex() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::vector< int > /*[1:?]*/ v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcTriangulatedFaceSet::setPnIndex(const std::optional< std::vector< int > /*[1:?]*/ >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTriangulatedFaceSet::Class() { return *((IfcParse::entity*)IFC4_types[1098]); }
|
|
void Ifc4::IfcTriangulatedFaceSet::initialize(::Ifc4::IfcCartesianPointList3D v1_Coordinates, std::optional< std::vector< std::vector< double > > > v2_Normals, std::optional< bool > v3_Closed, std::vector< std::vector< int > > v4_CoordIndex, std::optional< std::vector< int > /*[1:?]*/ > v5_PnIndex) { set_attribute_value(0, (v1_Coordinates)); if (v2_Normals) {set_attribute_value(1, (*v2_Normals)); } if (v3_Closed) {set_attribute_value(2, (*v3_Closed)); }set_attribute_value(3, (v4_CoordIndex)); if (v5_PnIndex) {set_attribute_value(4, (*v5_PnIndex)); } }
|
|
|
|
// Function implementations for IfcTrimmedCurve
|
|
::Ifc4::IfcCurve Ifc4::IfcTrimmedCurve::BasisCurve() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcCurve>(); }
|
|
void Ifc4::IfcTrimmedCurve::setBasisCurve(const ::Ifc4::IfcCurve& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
std::vector< ::Ifc4::IfcTrimmingSelect > Ifc4::IfcTrimmedCurve::Trim1() const { std::vector<express::Base> es = get_attribute_value(1); return cast_vector<::Ifc4::IfcTrimmingSelect>(es); }
|
|
void Ifc4::IfcTrimmedCurve::setTrim1(const std::vector< ::Ifc4::IfcTrimmingSelect >& v) { set_attribute_value(1, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(1); }
|
|
std::vector< ::Ifc4::IfcTrimmingSelect > Ifc4::IfcTrimmedCurve::Trim2() const { std::vector<express::Base> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcTrimmingSelect>(es); }
|
|
void Ifc4::IfcTrimmedCurve::setTrim2(const std::vector< ::Ifc4::IfcTrimmingSelect >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
|
|
bool Ifc4::IfcTrimmedCurve::SenseAgreement() const { bool v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcTrimmedCurve::setSenseAgreement(const bool& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
::Ifc4::IfcTrimmingPreference::Value Ifc4::IfcTrimmedCurve::MasterRepresentation() const { return ::Ifc4::IfcTrimmingPreference::FromString(get_attribute_value(4)); }
|
|
void Ifc4::IfcTrimmedCurve::setMasterRepresentation(const ::Ifc4::IfcTrimmingPreference::Value& v) { set_attribute_value(4, EnumerationReference(&::Ifc4::IfcTrimmingPreference::Class(), (size_t) v));if constexpr (false)unset_attribute_value(4); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTrimmedCurve::Class() { return *((IfcParse::entity*)IFC4_types[1099]); }
|
|
void Ifc4::IfcTrimmedCurve::initialize(::Ifc4::IfcCurve v1_BasisCurve, std::vector< ::Ifc4::IfcTrimmingSelect > v2_Trim1, std::vector< ::Ifc4::IfcTrimmingSelect > v3_Trim2, bool v4_SenseAgreement, ::Ifc4::IfcTrimmingPreference::Value v5_MasterRepresentation) { set_attribute_value(0, (v1_BasisCurve));set_attribute_value(1, cast_vector<express::Base>(v2_Trim1));set_attribute_value(2, cast_vector<express::Base>(v3_Trim2));set_attribute_value(3, (v4_SenseAgreement));set_attribute_value(4, (EnumerationReference(&::Ifc4::IfcTrimmingPreference::Class(),(size_t)v5_MasterRepresentation))); }
|
|
|
|
// Function implementations for IfcTubeBundle
|
|
std::optional< ::Ifc4::IfcTubeBundleTypeEnum::Value > Ifc4::IfcTubeBundle::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcTubeBundleTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcTubeBundle::setPredefinedType(const std::optional< ::Ifc4::IfcTubeBundleTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcTubeBundleTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTubeBundle::Class() { return *((IfcParse::entity*)IFC4_types[1103]); }
|
|
void Ifc4::IfcTubeBundle::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcTubeBundleTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcTubeBundleTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcTubeBundleType
|
|
::Ifc4::IfcTubeBundleTypeEnum::Value Ifc4::IfcTubeBundleType::PredefinedType() const { return ::Ifc4::IfcTubeBundleTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcTubeBundleType::setPredefinedType(const ::Ifc4::IfcTubeBundleTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcTubeBundleTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcTubeBundleType::Class() { return *((IfcParse::entity*)IFC4_types[1104]); }
|
|
void Ifc4::IfcTubeBundleType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcTubeBundleTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcTubeBundleTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcTypeObject
|
|
std::optional< std::string > Ifc4::IfcTypeObject::ApplicableOccurrence() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcTypeObject::setApplicableOccurrence(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > Ifc4::IfcTypeObject::HasPropertySets() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(5); return cast_vector<::Ifc4::IfcPropertySetDefinition>(es); }
|
|
void Ifc4::IfcTypeObject::setHasPropertySets(const std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > >& v) { if (v) {set_attribute_value(5, cast_vector<express::Base>(*v));} else {unset_attribute_value(5);} }
|
|
|
|
std::vector<::Ifc4::IfcRelDefinesByType> Ifc4::IfcTypeObject::Types() const { return cast_vector<IfcRelDefinesByType>(file()->getInverse(data()->id(), IFC4_types[832], 5)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcTypeObject::Class() { return *((IfcParse::entity*)IFC4_types[1106]); }
|
|
void Ifc4::IfcTypeObject::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } }
|
|
|
|
// Function implementations for IfcTypeProcess
|
|
std::optional< std::string > Ifc4::IfcTypeProcess::Identification() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcTypeProcess::setIdentification(const std::optional< std::string >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
std::optional< std::string > Ifc4::IfcTypeProcess::LongDescription() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::string v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcTypeProcess::setLongDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< std::string > Ifc4::IfcTypeProcess::ProcessType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcTypeProcess::setProcessType(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
|
|
std::vector<::Ifc4::IfcRelAssignsToProcess> Ifc4::IfcTypeProcess::OperatesOn() const { return cast_vector<IfcRelAssignsToProcess>(file()->getInverse(data()->id(), IFC4_types[803], 6)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcTypeProcess::Class() { return *((IfcParse::entity*)IFC4_types[1107]); }
|
|
void Ifc4::IfcTypeProcess::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::string > v7_Identification, std::optional< std::string > v8_LongDescription, std::optional< std::string > v9_ProcessType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_Identification) {set_attribute_value(6, (*v7_Identification)); } if (v8_LongDescription) {set_attribute_value(7, (*v8_LongDescription)); } if (v9_ProcessType) {set_attribute_value(8, (*v9_ProcessType)); } }
|
|
|
|
// Function implementations for IfcTypeProduct
|
|
std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > Ifc4::IfcTypeProduct::RepresentationMaps() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(6); return cast_vector<::Ifc4::IfcRepresentationMap>(es); }
|
|
void Ifc4::IfcTypeProduct::setRepresentationMaps(const std::optional< std::vector< ::Ifc4::IfcRepresentationMap > >& v) { if (v) {set_attribute_value(6, cast_vector<express::Base>(*v));} else {unset_attribute_value(6);} }
|
|
std::optional< std::string > Ifc4::IfcTypeProduct::Tag() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::string v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcTypeProduct::setTag(const std::optional< std::string >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
|
|
std::vector<::Ifc4::IfcRelAssignsToProduct> Ifc4::IfcTypeProduct::ReferencedBy() const { return cast_vector<IfcRelAssignsToProduct>(file()->getInverse(data()->id(), IFC4_types[804], 6)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcTypeProduct::Class() { return *((IfcParse::entity*)IFC4_types[1108]); }
|
|
void Ifc4::IfcTypeProduct::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcTypeResource
|
|
std::optional< std::string > Ifc4::IfcTypeResource::Identification() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcTypeResource::setIdentification(const std::optional< std::string >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
std::optional< std::string > Ifc4::IfcTypeResource::LongDescription() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::string v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcTypeResource::setLongDescription(const std::optional< std::string >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< std::string > Ifc4::IfcTypeResource::ResourceType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcTypeResource::setResourceType(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
|
|
std::vector<::Ifc4::IfcRelAssignsToResource> Ifc4::IfcTypeResource::ResourceOf() const { return cast_vector<IfcRelAssignsToResource>(file()->getInverse(data()->id(), IFC4_types[805], 6)); }
|
|
|
|
const IfcParse::entity& Ifc4::IfcTypeResource::Class() { return *((IfcParse::entity*)IFC4_types[1109]); }
|
|
void Ifc4::IfcTypeResource::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::string > v7_Identification, std::optional< std::string > v8_LongDescription, std::optional< std::string > v9_ResourceType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_Identification) {set_attribute_value(6, (*v7_Identification)); } if (v8_LongDescription) {set_attribute_value(7, (*v8_LongDescription)); } if (v9_ResourceType) {set_attribute_value(8, (*v9_ResourceType)); } }
|
|
|
|
// Function implementations for IfcUShapeProfileDef
|
|
double Ifc4::IfcUShapeProfileDef::Depth() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcUShapeProfileDef::setDepth(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
double Ifc4::IfcUShapeProfileDef::FlangeWidth() const { double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcUShapeProfileDef::setFlangeWidth(const double& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
double Ifc4::IfcUShapeProfileDef::WebThickness() const { double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcUShapeProfileDef::setWebThickness(const double& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
double Ifc4::IfcUShapeProfileDef::FlangeThickness() const { double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcUShapeProfileDef::setFlangeThickness(const double& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
std::optional< double > Ifc4::IfcUShapeProfileDef::FilletRadius() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcUShapeProfileDef::setFilletRadius(const std::optional< double >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< double > Ifc4::IfcUShapeProfileDef::EdgeRadius() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } double v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcUShapeProfileDef::setEdgeRadius(const std::optional< double >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
std::optional< double > Ifc4::IfcUShapeProfileDef::FlangeSlope() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } double v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcUShapeProfileDef::setFlangeSlope(const std::optional< double >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcUShapeProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[1120]); }
|
|
void Ifc4::IfcUShapeProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcAxis2Placement2D v3_Position, double v4_Depth, double v5_FlangeWidth, double v6_WebThickness, double v7_FlangeThickness, std::optional< double > v8_FilletRadius, std::optional< double > v9_EdgeRadius, std::optional< double > v10_FlangeSlope) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Position));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)); } }
|
|
|
|
// Function implementations for IfcUnitAssignment
|
|
std::vector< ::Ifc4::IfcUnit > Ifc4::IfcUnitAssignment::Units() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcUnit>(es); }
|
|
void Ifc4::IfcUnitAssignment::setUnits(const std::vector< ::Ifc4::IfcUnit >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcUnitAssignment::Class() { return *((IfcParse::entity*)IFC4_types[1117]); }
|
|
void Ifc4::IfcUnitAssignment::initialize(std::vector< ::Ifc4::IfcUnit > v1_Units) { set_attribute_value(0, cast_vector<express::Base>(v1_Units)); }
|
|
|
|
// Function implementations for IfcUnitaryControlElement
|
|
std::optional< ::Ifc4::IfcUnitaryControlElementTypeEnum::Value > Ifc4::IfcUnitaryControlElement::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcUnitaryControlElementTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcUnitaryControlElement::setPredefinedType(const std::optional< ::Ifc4::IfcUnitaryControlElementTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcUnitaryControlElementTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcUnitaryControlElement::Class() { return *((IfcParse::entity*)IFC4_types[1111]); }
|
|
void Ifc4::IfcUnitaryControlElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcUnitaryControlElementTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcUnitaryControlElementTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcUnitaryControlElementType
|
|
::Ifc4::IfcUnitaryControlElementTypeEnum::Value Ifc4::IfcUnitaryControlElementType::PredefinedType() const { return ::Ifc4::IfcUnitaryControlElementTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcUnitaryControlElementType::setPredefinedType(const ::Ifc4::IfcUnitaryControlElementTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcUnitaryControlElementTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcUnitaryControlElementType::Class() { return *((IfcParse::entity*)IFC4_types[1112]); }
|
|
void Ifc4::IfcUnitaryControlElementType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcUnitaryControlElementTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcUnitaryControlElementTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcUnitaryEquipment
|
|
std::optional< ::Ifc4::IfcUnitaryEquipmentTypeEnum::Value > Ifc4::IfcUnitaryEquipment::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcUnitaryEquipmentTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcUnitaryEquipment::setPredefinedType(const std::optional< ::Ifc4::IfcUnitaryEquipmentTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcUnitaryEquipmentTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcUnitaryEquipment::Class() { return *((IfcParse::entity*)IFC4_types[1114]); }
|
|
void Ifc4::IfcUnitaryEquipment::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcUnitaryEquipmentTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcUnitaryEquipmentTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcUnitaryEquipmentType
|
|
::Ifc4::IfcUnitaryEquipmentTypeEnum::Value Ifc4::IfcUnitaryEquipmentType::PredefinedType() const { return ::Ifc4::IfcUnitaryEquipmentTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcUnitaryEquipmentType::setPredefinedType(const ::Ifc4::IfcUnitaryEquipmentTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcUnitaryEquipmentTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcUnitaryEquipmentType::Class() { return *((IfcParse::entity*)IFC4_types[1115]); }
|
|
void Ifc4::IfcUnitaryEquipmentType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcUnitaryEquipmentTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcUnitaryEquipmentTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcValve
|
|
std::optional< ::Ifc4::IfcValveTypeEnum::Value > Ifc4::IfcValve::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcValveTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcValve::setPredefinedType(const std::optional< ::Ifc4::IfcValveTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcValveTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcValve::Class() { return *((IfcParse::entity*)IFC4_types[1122]); }
|
|
void Ifc4::IfcValve::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcValveTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcValveTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcValveType
|
|
::Ifc4::IfcValveTypeEnum::Value Ifc4::IfcValveType::PredefinedType() const { return ::Ifc4::IfcValveTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcValveType::setPredefinedType(const ::Ifc4::IfcValveTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcValveTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcValveType::Class() { return *((IfcParse::entity*)IFC4_types[1123]); }
|
|
void Ifc4::IfcValveType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcValveTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcValveTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcVector
|
|
::Ifc4::IfcDirection Ifc4::IfcVector::Orientation() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcDirection>(); }
|
|
void Ifc4::IfcVector::setOrientation(const ::Ifc4::IfcDirection& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
double Ifc4::IfcVector::Magnitude() const { double v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcVector::setMagnitude(const double& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcVector::Class() { return *((IfcParse::entity*)IFC4_types[1126]); }
|
|
void Ifc4::IfcVector::initialize(::Ifc4::IfcDirection v1_Orientation, double v2_Magnitude) { set_attribute_value(0, (v1_Orientation));set_attribute_value(1, (v2_Magnitude)); }
|
|
|
|
// Function implementations for IfcVertex
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcVertex::Class() { return *((IfcParse::entity*)IFC4_types[1128]); }
|
|
void Ifc4::IfcVertex::initialize() { }
|
|
|
|
// Function implementations for IfcVertexLoop
|
|
::Ifc4::IfcVertex Ifc4::IfcVertexLoop::LoopVertex() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcVertex>(); }
|
|
void Ifc4::IfcVertexLoop::setLoopVertex(const ::Ifc4::IfcVertex& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcVertexLoop::Class() { return *((IfcParse::entity*)IFC4_types[1129]); }
|
|
void Ifc4::IfcVertexLoop::initialize(::Ifc4::IfcVertex v1_LoopVertex) { set_attribute_value(0, (v1_LoopVertex)); }
|
|
|
|
// Function implementations for IfcVertexPoint
|
|
::Ifc4::IfcPoint Ifc4::IfcVertexPoint::VertexGeometry() const { return ((express::Base)(get_attribute_value(0))).as<::Ifc4::IfcPoint>(); }
|
|
void Ifc4::IfcVertexPoint::setVertexGeometry(const ::Ifc4::IfcPoint& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcVertexPoint::Class() { return *((IfcParse::entity*)IFC4_types[1130]); }
|
|
void Ifc4::IfcVertexPoint::initialize(::Ifc4::IfcPoint v1_VertexGeometry) { set_attribute_value(0, (v1_VertexGeometry)); }
|
|
|
|
// Function implementations for IfcVibrationIsolator
|
|
std::optional< ::Ifc4::IfcVibrationIsolatorTypeEnum::Value > Ifc4::IfcVibrationIsolator::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcVibrationIsolatorTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcVibrationIsolator::setPredefinedType(const std::optional< ::Ifc4::IfcVibrationIsolatorTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcVibrationIsolatorTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcVibrationIsolator::Class() { return *((IfcParse::entity*)IFC4_types[1131]); }
|
|
void Ifc4::IfcVibrationIsolator::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcVibrationIsolatorTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcVibrationIsolatorTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcVibrationIsolatorType
|
|
::Ifc4::IfcVibrationIsolatorTypeEnum::Value Ifc4::IfcVibrationIsolatorType::PredefinedType() const { return ::Ifc4::IfcVibrationIsolatorTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcVibrationIsolatorType::setPredefinedType(const ::Ifc4::IfcVibrationIsolatorTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcVibrationIsolatorTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcVibrationIsolatorType::Class() { return *((IfcParse::entity*)IFC4_types[1132]); }
|
|
void Ifc4::IfcVibrationIsolatorType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcVibrationIsolatorTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcVibrationIsolatorTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcVirtualElement
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcVirtualElement::Class() { return *((IfcParse::entity*)IFC4_types[1134]); }
|
|
void Ifc4::IfcVirtualElement::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } }
|
|
|
|
// Function implementations for IfcVirtualGridIntersection
|
|
std::vector< ::Ifc4::IfcGridAxis > Ifc4::IfcVirtualGridIntersection::IntersectingAxes() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcGridAxis>(es); }
|
|
void Ifc4::IfcVirtualGridIntersection::setIntersectingAxes(const std::vector< ::Ifc4::IfcGridAxis >& v) { set_attribute_value(0, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(0); }
|
|
std::vector< double > /*[2:3]*/ Ifc4::IfcVirtualGridIntersection::OffsetDistances() const { std::vector< double > /*[2:3]*/ v = get_attribute_value(1); return v; }
|
|
void Ifc4::IfcVirtualGridIntersection::setOffsetDistances(const std::vector< double > /*[2:3]*/& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcVirtualGridIntersection::Class() { return *((IfcParse::entity*)IFC4_types[1135]); }
|
|
void Ifc4::IfcVirtualGridIntersection::initialize(std::vector< ::Ifc4::IfcGridAxis > v1_IntersectingAxes, std::vector< double > /*[2:3]*/ v2_OffsetDistances) { set_attribute_value(0, cast_vector<express::Base>(v1_IntersectingAxes));set_attribute_value(1, (v2_OffsetDistances)); }
|
|
|
|
// Function implementations for IfcVoidingFeature
|
|
std::optional< ::Ifc4::IfcVoidingFeatureTypeEnum::Value > Ifc4::IfcVoidingFeature::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcVoidingFeatureTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcVoidingFeature::setPredefinedType(const std::optional< ::Ifc4::IfcVoidingFeatureTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcVoidingFeatureTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcVoidingFeature::Class() { return *((IfcParse::entity*)IFC4_types[1136]); }
|
|
void Ifc4::IfcVoidingFeature::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcVoidingFeatureTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcVoidingFeatureTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcWall
|
|
std::optional< ::Ifc4::IfcWallTypeEnum::Value > Ifc4::IfcWall::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcWallTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcWall::setPredefinedType(const std::optional< ::Ifc4::IfcWallTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcWallTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcWall::Class() { return *((IfcParse::entity*)IFC4_types[1140]); }
|
|
void Ifc4::IfcWall::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcWallTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcWallTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcWallElementedCase
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcWallElementedCase::Class() { return *((IfcParse::entity*)IFC4_types[1141]); }
|
|
void Ifc4::IfcWallElementedCase::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcWallTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcWallTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcWallStandardCase
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcWallStandardCase::Class() { return *((IfcParse::entity*)IFC4_types[1142]); }
|
|
void Ifc4::IfcWallStandardCase::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcWallTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcWallTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcWallType
|
|
::Ifc4::IfcWallTypeEnum::Value Ifc4::IfcWallType::PredefinedType() const { return ::Ifc4::IfcWallTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcWallType::setPredefinedType(const ::Ifc4::IfcWallTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcWallTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcWallType::Class() { return *((IfcParse::entity*)IFC4_types[1143]); }
|
|
void Ifc4::IfcWallType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcWallTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcWallTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcWasteTerminal
|
|
std::optional< ::Ifc4::IfcWasteTerminalTypeEnum::Value > Ifc4::IfcWasteTerminal::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcWasteTerminalTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcWasteTerminal::setPredefinedType(const std::optional< ::Ifc4::IfcWasteTerminalTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcWasteTerminalTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcWasteTerminal::Class() { return *((IfcParse::entity*)IFC4_types[1148]); }
|
|
void Ifc4::IfcWasteTerminal::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< ::Ifc4::IfcWasteTerminalTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcWasteTerminalTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcWasteTerminalType
|
|
::Ifc4::IfcWasteTerminalTypeEnum::Value Ifc4::IfcWasteTerminalType::PredefinedType() const { return ::Ifc4::IfcWasteTerminalTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcWasteTerminalType::setPredefinedType(const ::Ifc4::IfcWasteTerminalTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcWasteTerminalTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcWasteTerminalType::Class() { return *((IfcParse::entity*)IFC4_types[1149]); }
|
|
void Ifc4::IfcWasteTerminalType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcWasteTerminalTypeEnum::Value v10_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcWasteTerminalTypeEnum::Class(),(size_t)v10_PredefinedType))); }
|
|
|
|
// Function implementations for IfcWindow
|
|
std::optional< double > Ifc4::IfcWindow::OverallHeight() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } double v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcWindow::setOverallHeight(const std::optional< double >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
std::optional< double > Ifc4::IfcWindow::OverallWidth() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } double v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcWindow::setOverallWidth(const std::optional< double >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
std::optional< ::Ifc4::IfcWindowTypeEnum::Value > Ifc4::IfcWindow::PredefinedType() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } return ::Ifc4::IfcWindowTypeEnum::FromString(get_attribute_value(10)); }
|
|
void Ifc4::IfcWindow::setPredefinedType(const std::optional< ::Ifc4::IfcWindowTypeEnum::Value >& v) { if (v) {set_attribute_value(10, EnumerationReference(&::Ifc4::IfcWindowTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(10);} }
|
|
std::optional< ::Ifc4::IfcWindowTypePartitioningEnum::Value > Ifc4::IfcWindow::PartitioningType() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } return ::Ifc4::IfcWindowTypePartitioningEnum::FromString(get_attribute_value(11)); }
|
|
void Ifc4::IfcWindow::setPartitioningType(const std::optional< ::Ifc4::IfcWindowTypePartitioningEnum::Value >& v) { if (v) {set_attribute_value(11, EnumerationReference(&::Ifc4::IfcWindowTypePartitioningEnum::Class(), (size_t) *v));} else {unset_attribute_value(11);} }
|
|
std::optional< std::string > Ifc4::IfcWindow::UserDefinedPartitioningType() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } std::string v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcWindow::setUserDefinedPartitioningType(const std::optional< std::string >& v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcWindow::Class() { return *((IfcParse::entity*)IFC4_types[1151]); }
|
|
void Ifc4::IfcWindow::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< double > v9_OverallHeight, std::optional< double > v10_OverallWidth, std::optional< ::Ifc4::IfcWindowTypeEnum::Value > v11_PredefinedType, std::optional< ::Ifc4::IfcWindowTypePartitioningEnum::Value > v12_PartitioningType, std::optional< std::string > v13_UserDefinedPartitioningType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); 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)); } if (v11_PredefinedType) {set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcWindowTypeEnum::Class(),(size_t)*v11_PredefinedType))); } if (v12_PartitioningType) {set_attribute_value(11, (EnumerationReference(&::Ifc4::IfcWindowTypePartitioningEnum::Class(),(size_t)*v12_PartitioningType))); } if (v13_UserDefinedPartitioningType) {set_attribute_value(12, (*v13_UserDefinedPartitioningType)); } }
|
|
|
|
// Function implementations for IfcWindowLiningProperties
|
|
std::optional< double > Ifc4::IfcWindowLiningProperties::LiningDepth() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcWindowLiningProperties::setLiningDepth(const std::optional< double >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< double > Ifc4::IfcWindowLiningProperties::LiningThickness() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcWindowLiningProperties::setLiningThickness(const std::optional< double >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
std::optional< double > Ifc4::IfcWindowLiningProperties::TransomThickness() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcWindowLiningProperties::setTransomThickness(const std::optional< double >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
std::optional< double > Ifc4::IfcWindowLiningProperties::MullionThickness() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcWindowLiningProperties::setMullionThickness(const std::optional< double >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< double > Ifc4::IfcWindowLiningProperties::FirstTransomOffset() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } double v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcWindowLiningProperties::setFirstTransomOffset(const std::optional< double >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
std::optional< double > Ifc4::IfcWindowLiningProperties::SecondTransomOffset() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } double v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcWindowLiningProperties::setSecondTransomOffset(const std::optional< double >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
std::optional< double > Ifc4::IfcWindowLiningProperties::FirstMullionOffset() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } double v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcWindowLiningProperties::setFirstMullionOffset(const std::optional< double >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::optional< double > Ifc4::IfcWindowLiningProperties::SecondMullionOffset() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } double v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcWindowLiningProperties::setSecondMullionOffset(const std::optional< double >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
::Ifc4::IfcShapeAspect Ifc4::IfcWindowLiningProperties::ShapeAspectStyle() const { if(get_attribute_value(12).isNull()) { return ::Ifc4::IfcShapeAspect{}; } return ((express::Base)(get_attribute_value(12))).as<::Ifc4::IfcShapeAspect>(); }
|
|
void Ifc4::IfcWindowLiningProperties::setShapeAspectStyle(const ::Ifc4::IfcShapeAspect& v) { set_attribute_value(12, v);if constexpr (false)unset_attribute_value(12); }
|
|
std::optional< double > Ifc4::IfcWindowLiningProperties::LiningOffset() const { if(get_attribute_value(13).isNull()) { return std::nullopt; } double v = get_attribute_value(13); return v; }
|
|
void Ifc4::IfcWindowLiningProperties::setLiningOffset(const std::optional< double >& v) { if (v) {set_attribute_value(13, *v);} else {unset_attribute_value(13);} }
|
|
std::optional< double > Ifc4::IfcWindowLiningProperties::LiningToPanelOffsetX() const { if(get_attribute_value(14).isNull()) { return std::nullopt; } double v = get_attribute_value(14); return v; }
|
|
void Ifc4::IfcWindowLiningProperties::setLiningToPanelOffsetX(const std::optional< double >& v) { if (v) {set_attribute_value(14, *v);} else {unset_attribute_value(14);} }
|
|
std::optional< double > Ifc4::IfcWindowLiningProperties::LiningToPanelOffsetY() const { if(get_attribute_value(15).isNull()) { return std::nullopt; } double v = get_attribute_value(15); return v; }
|
|
void Ifc4::IfcWindowLiningProperties::setLiningToPanelOffsetY(const std::optional< double >& v) { if (v) {set_attribute_value(15, *v);} else {unset_attribute_value(15);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcWindowLiningProperties::Class() { return *((IfcParse::entity*)IFC4_types[1152]); }
|
|
void Ifc4::IfcWindowLiningProperties::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< double > v5_LiningDepth, std::optional< double > v6_LiningThickness, std::optional< double > v7_TransomThickness, std::optional< double > v8_MullionThickness, std::optional< double > v9_FirstTransomOffset, std::optional< double > v10_SecondTransomOffset, std::optional< double > v11_FirstMullionOffset, std::optional< double > v12_SecondMullionOffset, ::Ifc4::IfcShapeAspect v13_ShapeAspectStyle, std::optional< double > v14_LiningOffset, std::optional< double > v15_LiningToPanelOffsetX, std::optional< double > v16_LiningToPanelOffsetY) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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)); if (v14_LiningOffset) {set_attribute_value(13, (*v14_LiningOffset)); } if (v15_LiningToPanelOffsetX) {set_attribute_value(14, (*v15_LiningToPanelOffsetX)); } if (v16_LiningToPanelOffsetY) {set_attribute_value(15, (*v16_LiningToPanelOffsetY)); } }
|
|
|
|
// Function implementations for IfcWindowPanelProperties
|
|
::Ifc4::IfcWindowPanelOperationEnum::Value Ifc4::IfcWindowPanelProperties::OperationType() const { return ::Ifc4::IfcWindowPanelOperationEnum::FromString(get_attribute_value(4)); }
|
|
void Ifc4::IfcWindowPanelProperties::setOperationType(const ::Ifc4::IfcWindowPanelOperationEnum::Value& v) { set_attribute_value(4, EnumerationReference(&::Ifc4::IfcWindowPanelOperationEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(4); }
|
|
::Ifc4::IfcWindowPanelPositionEnum::Value Ifc4::IfcWindowPanelProperties::PanelPosition() const { return ::Ifc4::IfcWindowPanelPositionEnum::FromString(get_attribute_value(5)); }
|
|
void Ifc4::IfcWindowPanelProperties::setPanelPosition(const ::Ifc4::IfcWindowPanelPositionEnum::Value& v) { set_attribute_value(5, EnumerationReference(&::Ifc4::IfcWindowPanelPositionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(5); }
|
|
std::optional< double > Ifc4::IfcWindowPanelProperties::FrameDepth() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcWindowPanelProperties::setFrameDepth(const std::optional< double >& v) { if (v) {set_attribute_value(6, *v);} else {unset_attribute_value(6);} }
|
|
std::optional< double > Ifc4::IfcWindowPanelProperties::FrameThickness() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcWindowPanelProperties::setFrameThickness(const std::optional< double >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
::Ifc4::IfcShapeAspect Ifc4::IfcWindowPanelProperties::ShapeAspectStyle() const { if(get_attribute_value(8).isNull()) { return ::Ifc4::IfcShapeAspect{}; } return ((express::Base)(get_attribute_value(8))).as<::Ifc4::IfcShapeAspect>(); }
|
|
void Ifc4::IfcWindowPanelProperties::setShapeAspectStyle(const ::Ifc4::IfcShapeAspect& v) { set_attribute_value(8, v);if constexpr (false)unset_attribute_value(8); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcWindowPanelProperties::Class() { return *((IfcParse::entity*)IFC4_types[1155]); }
|
|
void Ifc4::IfcWindowPanelProperties::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, ::Ifc4::IfcWindowPanelOperationEnum::Value v5_OperationType, ::Ifc4::IfcWindowPanelPositionEnum::Value v6_PanelPosition, std::optional< double > v7_FrameDepth, std::optional< double > v8_FrameThickness, ::Ifc4::IfcShapeAspect v9_ShapeAspectStyle) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); if (v3_Name) {set_attribute_value(2, (*v3_Name)); } if (v4_Description) {set_attribute_value(3, (*v4_Description)); }set_attribute_value(4, (EnumerationReference(&::Ifc4::IfcWindowPanelOperationEnum::Class(),(size_t)v5_OperationType)));set_attribute_value(5, (EnumerationReference(&::Ifc4::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)); }
|
|
|
|
// Function implementations for IfcWindowStandardCase
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcWindowStandardCase::Class() { return *((IfcParse::entity*)IFC4_types[1156]); }
|
|
void Ifc4::IfcWindowStandardCase::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, ::Ifc4::IfcObjectPlacement v6_ObjectPlacement, ::Ifc4::IfcProductRepresentation v7_Representation, std::optional< std::string > v8_Tag, std::optional< double > v9_OverallHeight, std::optional< double > v10_OverallWidth, std::optional< ::Ifc4::IfcWindowTypeEnum::Value > v11_PredefinedType, std::optional< ::Ifc4::IfcWindowTypePartitioningEnum::Value > v12_PartitioningType, std::optional< std::string > v13_UserDefinedPartitioningType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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));set_attribute_value(6, (v7_Representation)); 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)); } if (v11_PredefinedType) {set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcWindowTypeEnum::Class(),(size_t)*v11_PredefinedType))); } if (v12_PartitioningType) {set_attribute_value(11, (EnumerationReference(&::Ifc4::IfcWindowTypePartitioningEnum::Class(),(size_t)*v12_PartitioningType))); } if (v13_UserDefinedPartitioningType) {set_attribute_value(12, (*v13_UserDefinedPartitioningType)); } }
|
|
|
|
// Function implementations for IfcWindowStyle
|
|
::Ifc4::IfcWindowStyleConstructionEnum::Value Ifc4::IfcWindowStyle::ConstructionType() const { return ::Ifc4::IfcWindowStyleConstructionEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcWindowStyle::setConstructionType(const ::Ifc4::IfcWindowStyleConstructionEnum::Value& v) { set_attribute_value(8, EnumerationReference(&::Ifc4::IfcWindowStyleConstructionEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(8); }
|
|
::Ifc4::IfcWindowStyleOperationEnum::Value Ifc4::IfcWindowStyle::OperationType() const { return ::Ifc4::IfcWindowStyleOperationEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcWindowStyle::setOperationType(const ::Ifc4::IfcWindowStyleOperationEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcWindowStyleOperationEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
bool Ifc4::IfcWindowStyle::ParameterTakesPrecedence() const { bool v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcWindowStyle::setParameterTakesPrecedence(const bool& v) { set_attribute_value(10, v);if constexpr (false)unset_attribute_value(10); }
|
|
bool Ifc4::IfcWindowStyle::Sizeable() const { bool v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcWindowStyle::setSizeable(const bool& v) { set_attribute_value(11, v);if constexpr (false)unset_attribute_value(11); }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcWindowStyle::Class() { return *((IfcParse::entity*)IFC4_types[1157]); }
|
|
void Ifc4::IfcWindowStyle::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, ::Ifc4::IfcWindowStyleConstructionEnum::Value v9_ConstructionType, ::Ifc4::IfcWindowStyleOperationEnum::Value v10_OperationType, bool v11_ParameterTakesPrecedence, bool v12_Sizeable) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); }set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcWindowStyleConstructionEnum::Class(),(size_t)v9_ConstructionType)));set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcWindowStyleOperationEnum::Class(),(size_t)v10_OperationType)));set_attribute_value(10, (v11_ParameterTakesPrecedence));set_attribute_value(11, (v12_Sizeable)); }
|
|
|
|
// Function implementations for IfcWindowType
|
|
::Ifc4::IfcWindowTypeEnum::Value Ifc4::IfcWindowType::PredefinedType() const { return ::Ifc4::IfcWindowTypeEnum::FromString(get_attribute_value(9)); }
|
|
void Ifc4::IfcWindowType::setPredefinedType(const ::Ifc4::IfcWindowTypeEnum::Value& v) { set_attribute_value(9, EnumerationReference(&::Ifc4::IfcWindowTypeEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(9); }
|
|
::Ifc4::IfcWindowTypePartitioningEnum::Value Ifc4::IfcWindowType::PartitioningType() const { return ::Ifc4::IfcWindowTypePartitioningEnum::FromString(get_attribute_value(10)); }
|
|
void Ifc4::IfcWindowType::setPartitioningType(const ::Ifc4::IfcWindowTypePartitioningEnum::Value& v) { set_attribute_value(10, EnumerationReference(&::Ifc4::IfcWindowTypePartitioningEnum::Class(), (size_t) v));if constexpr (false)unset_attribute_value(10); }
|
|
std::optional< bool > Ifc4::IfcWindowType::ParameterTakesPrecedence() const { if(get_attribute_value(11).isNull()) { return std::nullopt; } bool v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcWindowType::setParameterTakesPrecedence(const std::optional< bool >& v) { if (v) {set_attribute_value(11, *v);} else {unset_attribute_value(11);} }
|
|
std::optional< std::string > Ifc4::IfcWindowType::UserDefinedPartitioningType() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } std::string v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcWindowType::setUserDefinedPartitioningType(const std::optional< std::string >& v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcWindowType::Class() { return *((IfcParse::entity*)IFC4_types[1160]); }
|
|
void Ifc4::IfcWindowType::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ApplicableOccurrence, std::optional< std::vector< ::Ifc4::IfcPropertySetDefinition > > v6_HasPropertySets, std::optional< std::vector< ::Ifc4::IfcRepresentationMap > > v7_RepresentationMaps, std::optional< std::string > v8_Tag, std::optional< std::string > v9_ElementType, ::Ifc4::IfcWindowTypeEnum::Value v10_PredefinedType, ::Ifc4::IfcWindowTypePartitioningEnum::Value v11_PartitioningType, std::optional< bool > v12_ParameterTakesPrecedence, std::optional< std::string > v13_UserDefinedPartitioningType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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, cast_vector<express::Base>(*v6_HasPropertySets)); } if (v7_RepresentationMaps) {set_attribute_value(6, cast_vector<express::Base>(*v7_RepresentationMaps)); } if (v8_Tag) {set_attribute_value(7, (*v8_Tag)); } if (v9_ElementType) {set_attribute_value(8, (*v9_ElementType)); }set_attribute_value(9, (EnumerationReference(&::Ifc4::IfcWindowTypeEnum::Class(),(size_t)v10_PredefinedType)));set_attribute_value(10, (EnumerationReference(&::Ifc4::IfcWindowTypePartitioningEnum::Class(),(size_t)v11_PartitioningType))); if (v12_ParameterTakesPrecedence) {set_attribute_value(11, (*v12_ParameterTakesPrecedence)); } if (v13_UserDefinedPartitioningType) {set_attribute_value(12, (*v13_UserDefinedPartitioningType)); } }
|
|
|
|
// Function implementations for IfcWorkCalendar
|
|
std::optional< std::vector< ::Ifc4::IfcWorkTime > > Ifc4::IfcWorkCalendar::WorkingTimes() const { if(get_attribute_value(6).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(6); return cast_vector<::Ifc4::IfcWorkTime>(es); }
|
|
void Ifc4::IfcWorkCalendar::setWorkingTimes(const std::optional< std::vector< ::Ifc4::IfcWorkTime > >& v) { if (v) {set_attribute_value(6, cast_vector<express::Base>(*v));} else {unset_attribute_value(6);} }
|
|
std::optional< std::vector< ::Ifc4::IfcWorkTime > > Ifc4::IfcWorkCalendar::ExceptionTimes() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(7); return cast_vector<::Ifc4::IfcWorkTime>(es); }
|
|
void Ifc4::IfcWorkCalendar::setExceptionTimes(const std::optional< std::vector< ::Ifc4::IfcWorkTime > >& v) { if (v) {set_attribute_value(7, cast_vector<express::Base>(*v));} else {unset_attribute_value(7);} }
|
|
std::optional< ::Ifc4::IfcWorkCalendarTypeEnum::Value > Ifc4::IfcWorkCalendar::PredefinedType() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } return ::Ifc4::IfcWorkCalendarTypeEnum::FromString(get_attribute_value(8)); }
|
|
void Ifc4::IfcWorkCalendar::setPredefinedType(const std::optional< ::Ifc4::IfcWorkCalendarTypeEnum::Value >& v) { if (v) {set_attribute_value(8, EnumerationReference(&::Ifc4::IfcWorkCalendarTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcWorkCalendar::Class() { return *((IfcParse::entity*)IFC4_types[1163]); }
|
|
void Ifc4::IfcWorkCalendar::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::optional< std::vector< ::Ifc4::IfcWorkTime > > v7_WorkingTimes, std::optional< std::vector< ::Ifc4::IfcWorkTime > > v8_ExceptionTimes, std::optional< ::Ifc4::IfcWorkCalendarTypeEnum::Value > v9_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); } if (v7_WorkingTimes) {set_attribute_value(6, cast_vector<express::Base>(*v7_WorkingTimes)); } if (v8_ExceptionTimes) {set_attribute_value(7, cast_vector<express::Base>(*v8_ExceptionTimes)); } if (v9_PredefinedType) {set_attribute_value(8, (EnumerationReference(&::Ifc4::IfcWorkCalendarTypeEnum::Class(),(size_t)*v9_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcWorkControl
|
|
std::string Ifc4::IfcWorkControl::CreationDate() const { std::string v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcWorkControl::setCreationDate(const std::string& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
std::optional< std::vector< ::Ifc4::IfcPerson > > Ifc4::IfcWorkControl::Creators() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } std::vector<express::Base> es = get_attribute_value(7); return cast_vector<::Ifc4::IfcPerson>(es); }
|
|
void Ifc4::IfcWorkControl::setCreators(const std::optional< std::vector< ::Ifc4::IfcPerson > >& v) { if (v) {set_attribute_value(7, cast_vector<express::Base>(*v));} else {unset_attribute_value(7);} }
|
|
std::optional< std::string > Ifc4::IfcWorkControl::Purpose() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } std::string v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcWorkControl::setPurpose(const std::optional< std::string >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
std::optional< std::string > Ifc4::IfcWorkControl::Duration() const { if(get_attribute_value(9).isNull()) { return std::nullopt; } std::string v = get_attribute_value(9); return v; }
|
|
void Ifc4::IfcWorkControl::setDuration(const std::optional< std::string >& v) { if (v) {set_attribute_value(9, *v);} else {unset_attribute_value(9);} }
|
|
std::optional< std::string > Ifc4::IfcWorkControl::TotalFloat() const { if(get_attribute_value(10).isNull()) { return std::nullopt; } std::string v = get_attribute_value(10); return v; }
|
|
void Ifc4::IfcWorkControl::setTotalFloat(const std::optional< std::string >& v) { if (v) {set_attribute_value(10, *v);} else {unset_attribute_value(10);} }
|
|
std::string Ifc4::IfcWorkControl::StartTime() const { std::string v = get_attribute_value(11); return v; }
|
|
void Ifc4::IfcWorkControl::setStartTime(const std::string& v) { set_attribute_value(11, v);if constexpr (false)unset_attribute_value(11); }
|
|
std::optional< std::string > Ifc4::IfcWorkControl::FinishTime() const { if(get_attribute_value(12).isNull()) { return std::nullopt; } std::string v = get_attribute_value(12); return v; }
|
|
void Ifc4::IfcWorkControl::setFinishTime(const std::optional< std::string >& v) { if (v) {set_attribute_value(12, *v);} else {unset_attribute_value(12);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcWorkControl::Class() { return *((IfcParse::entity*)IFC4_types[1165]); }
|
|
void Ifc4::IfcWorkControl::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::string v7_CreationDate, std::optional< std::vector< ::Ifc4::IfcPerson > > v8_Creators, std::optional< std::string > v9_Purpose, std::optional< std::string > v10_Duration, std::optional< std::string > v11_TotalFloat, std::string v12_StartTime, std::optional< std::string > v13_FinishTime) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); }set_attribute_value(6, (v7_CreationDate)); if (v8_Creators) {set_attribute_value(7, cast_vector<express::Base>(*v8_Creators)); } 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)); if (v13_FinishTime) {set_attribute_value(12, (*v13_FinishTime)); } }
|
|
|
|
// Function implementations for IfcWorkPlan
|
|
std::optional< ::Ifc4::IfcWorkPlanTypeEnum::Value > Ifc4::IfcWorkPlan::PredefinedType() const { if(get_attribute_value(13).isNull()) { return std::nullopt; } return ::Ifc4::IfcWorkPlanTypeEnum::FromString(get_attribute_value(13)); }
|
|
void Ifc4::IfcWorkPlan::setPredefinedType(const std::optional< ::Ifc4::IfcWorkPlanTypeEnum::Value >& v) { if (v) {set_attribute_value(13, EnumerationReference(&::Ifc4::IfcWorkPlanTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(13);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcWorkPlan::Class() { return *((IfcParse::entity*)IFC4_types[1166]); }
|
|
void Ifc4::IfcWorkPlan::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::string v7_CreationDate, std::optional< std::vector< ::Ifc4::IfcPerson > > v8_Creators, std::optional< std::string > v9_Purpose, std::optional< std::string > v10_Duration, std::optional< std::string > v11_TotalFloat, std::string v12_StartTime, std::optional< std::string > v13_FinishTime, std::optional< ::Ifc4::IfcWorkPlanTypeEnum::Value > v14_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); }set_attribute_value(6, (v7_CreationDate)); if (v8_Creators) {set_attribute_value(7, cast_vector<express::Base>(*v8_Creators)); } 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)); if (v13_FinishTime) {set_attribute_value(12, (*v13_FinishTime)); } if (v14_PredefinedType) {set_attribute_value(13, (EnumerationReference(&::Ifc4::IfcWorkPlanTypeEnum::Class(),(size_t)*v14_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcWorkSchedule
|
|
std::optional< ::Ifc4::IfcWorkScheduleTypeEnum::Value > Ifc4::IfcWorkSchedule::PredefinedType() const { if(get_attribute_value(13).isNull()) { return std::nullopt; } return ::Ifc4::IfcWorkScheduleTypeEnum::FromString(get_attribute_value(13)); }
|
|
void Ifc4::IfcWorkSchedule::setPredefinedType(const std::optional< ::Ifc4::IfcWorkScheduleTypeEnum::Value >& v) { if (v) {set_attribute_value(13, EnumerationReference(&::Ifc4::IfcWorkScheduleTypeEnum::Class(), (size_t) *v));} else {unset_attribute_value(13);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcWorkSchedule::Class() { return *((IfcParse::entity*)IFC4_types[1168]); }
|
|
void Ifc4::IfcWorkSchedule::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_Identification, std::string v7_CreationDate, std::optional< std::vector< ::Ifc4::IfcPerson > > v8_Creators, std::optional< std::string > v9_Purpose, std::optional< std::string > v10_Duration, std::optional< std::string > v11_TotalFloat, std::string v12_StartTime, std::optional< std::string > v13_FinishTime, std::optional< ::Ifc4::IfcWorkScheduleTypeEnum::Value > v14_PredefinedType) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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_Identification) {set_attribute_value(5, (*v6_Identification)); }set_attribute_value(6, (v7_CreationDate)); if (v8_Creators) {set_attribute_value(7, cast_vector<express::Base>(*v8_Creators)); } 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)); if (v13_FinishTime) {set_attribute_value(12, (*v13_FinishTime)); } if (v14_PredefinedType) {set_attribute_value(13, (EnumerationReference(&::Ifc4::IfcWorkScheduleTypeEnum::Class(),(size_t)*v14_PredefinedType))); } }
|
|
|
|
// Function implementations for IfcWorkTime
|
|
::Ifc4::IfcRecurrencePattern Ifc4::IfcWorkTime::RecurrencePattern() const { if(get_attribute_value(3).isNull()) { return ::Ifc4::IfcRecurrencePattern{}; } return ((express::Base)(get_attribute_value(3))).as<::Ifc4::IfcRecurrencePattern>(); }
|
|
void Ifc4::IfcWorkTime::setRecurrencePattern(const ::Ifc4::IfcRecurrencePattern& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
std::optional< std::string > Ifc4::IfcWorkTime::Start() const { if(get_attribute_value(4).isNull()) { return std::nullopt; } std::string v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcWorkTime::setStart(const std::optional< std::string >& v) { if (v) {set_attribute_value(4, *v);} else {unset_attribute_value(4);} }
|
|
std::optional< std::string > Ifc4::IfcWorkTime::Finish() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcWorkTime::setFinish(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcWorkTime::Class() { return *((IfcParse::entity*)IFC4_types[1170]); }
|
|
void Ifc4::IfcWorkTime::initialize(std::optional< std::string > v1_Name, std::optional< ::Ifc4::IfcDataOriginEnum::Value > v2_DataOrigin, std::optional< std::string > v3_UserDefinedDataOrigin, ::Ifc4::IfcRecurrencePattern v4_RecurrencePattern, std::optional< std::string > v5_Start, std::optional< std::string > v6_Finish) { if (v1_Name) {set_attribute_value(0, (*v1_Name)); } if (v2_DataOrigin) {set_attribute_value(1, (EnumerationReference(&::Ifc4::IfcDataOriginEnum::Class(),(size_t)*v2_DataOrigin))); } if (v3_UserDefinedDataOrigin) {set_attribute_value(2, (*v3_UserDefinedDataOrigin)); }set_attribute_value(3, (v4_RecurrencePattern)); if (v5_Start) {set_attribute_value(4, (*v5_Start)); } if (v6_Finish) {set_attribute_value(5, (*v6_Finish)); } }
|
|
|
|
// Function implementations for IfcZShapeProfileDef
|
|
double Ifc4::IfcZShapeProfileDef::Depth() const { double v = get_attribute_value(3); return v; }
|
|
void Ifc4::IfcZShapeProfileDef::setDepth(const double& v) { set_attribute_value(3, v);if constexpr (false)unset_attribute_value(3); }
|
|
double Ifc4::IfcZShapeProfileDef::FlangeWidth() const { double v = get_attribute_value(4); return v; }
|
|
void Ifc4::IfcZShapeProfileDef::setFlangeWidth(const double& v) { set_attribute_value(4, v);if constexpr (false)unset_attribute_value(4); }
|
|
double Ifc4::IfcZShapeProfileDef::WebThickness() const { double v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcZShapeProfileDef::setWebThickness(const double& v) { set_attribute_value(5, v);if constexpr (false)unset_attribute_value(5); }
|
|
double Ifc4::IfcZShapeProfileDef::FlangeThickness() const { double v = get_attribute_value(6); return v; }
|
|
void Ifc4::IfcZShapeProfileDef::setFlangeThickness(const double& v) { set_attribute_value(6, v);if constexpr (false)unset_attribute_value(6); }
|
|
std::optional< double > Ifc4::IfcZShapeProfileDef::FilletRadius() const { if(get_attribute_value(7).isNull()) { return std::nullopt; } double v = get_attribute_value(7); return v; }
|
|
void Ifc4::IfcZShapeProfileDef::setFilletRadius(const std::optional< double >& v) { if (v) {set_attribute_value(7, *v);} else {unset_attribute_value(7);} }
|
|
std::optional< double > Ifc4::IfcZShapeProfileDef::EdgeRadius() const { if(get_attribute_value(8).isNull()) { return std::nullopt; } double v = get_attribute_value(8); return v; }
|
|
void Ifc4::IfcZShapeProfileDef::setEdgeRadius(const std::optional< double >& v) { if (v) {set_attribute_value(8, *v);} else {unset_attribute_value(8);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcZShapeProfileDef::Class() { return *((IfcParse::entity*)IFC4_types[1172]); }
|
|
void Ifc4::IfcZShapeProfileDef::initialize(::Ifc4::IfcProfileTypeEnum::Value v1_ProfileType, std::optional< std::string > v2_ProfileName, ::Ifc4::IfcAxis2Placement2D v3_Position, double v4_Depth, double v5_FlangeWidth, double v6_WebThickness, double v7_FlangeThickness, std::optional< double > v8_FilletRadius, std::optional< double > v9_EdgeRadius) { set_attribute_value(0, (EnumerationReference(&::Ifc4::IfcProfileTypeEnum::Class(),(size_t)v1_ProfileType))); if (v2_ProfileName) {set_attribute_value(1, (*v2_ProfileName)); }set_attribute_value(2, (v3_Position));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)); } }
|
|
|
|
// Function implementations for IfcZone
|
|
std::optional< std::string > Ifc4::IfcZone::LongName() const { if(get_attribute_value(5).isNull()) { return std::nullopt; } std::string v = get_attribute_value(5); return v; }
|
|
void Ifc4::IfcZone::setLongName(const std::optional< std::string >& v) { if (v) {set_attribute_value(5, *v);} else {unset_attribute_value(5);} }
|
|
|
|
|
|
const IfcParse::entity& Ifc4::IfcZone::Class() { return *((IfcParse::entity*)IFC4_types[1171]); }
|
|
void Ifc4::IfcZone::initialize(std::string v1_GlobalId, ::Ifc4::IfcOwnerHistory v2_OwnerHistory, std::optional< std::string > v3_Name, std::optional< std::string > v4_Description, std::optional< std::string > v5_ObjectType, std::optional< std::string > v6_LongName) { set_attribute_value(0, (v1_GlobalId));set_attribute_value(1, (v2_OwnerHistory)); 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)); } }
|
|
|