mirror of
https://github.com/IfcOpenShell/IfcOpenShell.git
synced 2026-08-09 17:31:45 +00:00
Dirk Olbrich
262 lines
7.5 KiB
C++
262 lines
7.5 KiB
C++
/********************************************************************************
|
|
* *
|
|
* 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/>. *
|
|
* *
|
|
********************************************************************************/
|
|
|
|
#include "IfcSchema.h"
|
|
|
|
#include "IfcBaseClass.h"
|
|
|
|
#ifdef HAS_SCHEMA_2x3
|
|
#include "Ifc2x3.h"
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4
|
|
#include "Ifc4.h"
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x1
|
|
#include "Ifc4x1.h"
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x2
|
|
#include "Ifc4x2.h"
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_rc1
|
|
#include "Ifc4x3_rc1.h"
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_rc2
|
|
#include "Ifc4x3_rc2.h"
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_rc3
|
|
#include "Ifc4x3_rc3.h"
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_rc4
|
|
#include "Ifc4x3_rc4.h"
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3
|
|
#include "Ifc4x3.h"
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_tc1
|
|
#include "Ifc4x3_tc1.h"
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_add1
|
|
#include "Ifc4x3_add1.h"
|
|
#endif
|
|
|
|
#include <map>
|
|
|
|
bool IfcParse::declaration::is(const std::string& name) const {
|
|
const std::string* name_ptr = &name;
|
|
if (std::any_of(name.begin(), name.end(), [](char c) { return std::islower(c); })) {
|
|
temp_string_() = name;
|
|
boost::to_upper(temp_string_());
|
|
name_ptr = &temp_string_();
|
|
}
|
|
|
|
if (name_upper_ == *name_ptr) {
|
|
return true;
|
|
}
|
|
|
|
if (this->as_entity() && this->as_entity()->supertype()) {
|
|
return this->as_entity()->supertype()->is(name);
|
|
} else if (this->as_type_declaration()) {
|
|
const IfcParse::named_type* nt = this->as_type_declaration()->declared_type()->as_named_type();
|
|
if (nt) {
|
|
return nt->is(name);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool IfcParse::declaration::is(const IfcParse::declaration& decl) const {
|
|
if (this == &decl) {
|
|
return true;
|
|
}
|
|
|
|
if (this->as_entity() && this->as_entity()->supertype()) {
|
|
return this->as_entity()->supertype()->is(decl);
|
|
} else if (this->as_type_declaration()) {
|
|
const IfcParse::named_type* nt = this->as_type_declaration()->declared_type()->as_named_type();
|
|
if (nt) {
|
|
return nt->is(decl);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool IfcParse::named_type::is(const std::string& name) const {
|
|
return declared_type()->is(name);
|
|
}
|
|
|
|
bool IfcParse::named_type::is(const IfcParse::declaration& decl) const {
|
|
return declared_type()->is(decl);
|
|
}
|
|
|
|
IfcParse::entity::~entity() {
|
|
for (auto attribute : attributes_) {
|
|
delete attribute;
|
|
}
|
|
for (auto inverse_attribute : inverse_attributes_) {
|
|
delete inverse_attribute;
|
|
}
|
|
}
|
|
static std::map<std::string, const IfcParse::schema_definition*> schemas;
|
|
|
|
IfcParse::schema_definition::schema_definition(const std::string& name, const std::vector<const declaration*>& declarations, instance_factory* factory)
|
|
: name_(name),
|
|
declarations_(declarations),
|
|
factory_(factory) {
|
|
std::sort(declarations_.begin(), declarations_.end(), declaration_by_index_sort());
|
|
for (std::vector<const declaration*>::iterator it = declarations_.begin(); it != declarations_.end(); ++it) {
|
|
(**it).schema_ = this;
|
|
|
|
if ((**it).as_type_declaration()) {
|
|
type_declarations_.push_back((**it).as_type_declaration());
|
|
}
|
|
if ((**it).as_select_type()) {
|
|
select_types_.push_back((**it).as_select_type());
|
|
}
|
|
if ((**it).as_enumeration_type()) {
|
|
enumeration_types_.push_back((**it).as_enumeration_type());
|
|
}
|
|
if ((**it).as_entity()) {
|
|
entities_.push_back((**it).as_entity());
|
|
}
|
|
}
|
|
schemas[name_] = this;
|
|
}
|
|
|
|
IfcParse::schema_definition::~schema_definition() {
|
|
for (std::vector<const declaration*>::const_iterator it = declarations_.begin(); it != declarations_.end(); ++it) {
|
|
delete *it;
|
|
}
|
|
delete factory_;
|
|
}
|
|
|
|
IfcUtil::IfcBaseClass* IfcParse::schema_definition::instantiate(IfcEntityInstanceData* data) const {
|
|
if (factory_) {
|
|
return (*factory_)(data);
|
|
} else {
|
|
return new IfcUtil::IfcLateBoundEntity(data->type(), data);
|
|
}
|
|
}
|
|
|
|
void IfcParse::register_schema(schema_definition* s) {
|
|
schemas.insert({boost::to_upper_copy(s->name()), s});
|
|
}
|
|
|
|
const IfcParse::schema_definition* IfcParse::schema_by_name(const std::string& name) {
|
|
// TODO: initialize automatically somehow
|
|
#ifdef HAS_SCHEMA_2x3
|
|
Ifc2x3::get_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4
|
|
Ifc4::get_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x1
|
|
Ifc4x1::get_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x2
|
|
Ifc4x2::get_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_rc1
|
|
Ifc4x3_rc1::get_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_rc2
|
|
Ifc4x3_rc2::get_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_rc3
|
|
Ifc4x3_rc3::get_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_rc4
|
|
Ifc4x3_rc4::get_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3
|
|
Ifc4x3::get_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_tc1
|
|
Ifc4x3_tc1::get_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_add1
|
|
Ifc4x3_add1::get_schema();
|
|
#endif
|
|
|
|
std::map<std::string, const IfcParse::schema_definition*>::const_iterator it = schemas.find(boost::to_upper_copy(name));
|
|
if (it == schemas.end()) {
|
|
throw IfcParse::IfcException("No schema named " + name);
|
|
}
|
|
return it->second;
|
|
}
|
|
|
|
std::vector<std::string> IfcParse::schema_names() {
|
|
// Load schema modules
|
|
try {
|
|
IfcParse::schema_by_name("IFC2X3");
|
|
} catch (IfcParse::IfcException&) {
|
|
}
|
|
|
|
// Populate vector with map keys
|
|
std::vector<std::string> return_value;
|
|
for (auto& pair : schemas) {
|
|
return_value.push_back(pair.first);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
void IfcParse::clear_schemas() {
|
|
#ifdef HAS_SCHEMA_2x3
|
|
Ifc2x3::clear_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4
|
|
Ifc4::clear_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x1
|
|
Ifc4x1::clear_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x2
|
|
Ifc4x2::clear_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_rc1
|
|
Ifc4x3_rc1::clear_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_rc2
|
|
Ifc4x3_rc2::clear_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_rc3
|
|
Ifc4x3_rc3::clear_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_rc4
|
|
Ifc4x3_rc4::clear_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3
|
|
Ifc4x3::clear_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_tc1
|
|
Ifc4x3_tc1::clear_schema();
|
|
#endif
|
|
#ifdef HAS_SCHEMA_4x3_add1
|
|
Ifc4x3_add1::clear_schema();
|
|
#endif
|
|
|
|
// clear any remaining registered schemas
|
|
// we pop schemas until map is empty, because map iteration is invalidated after each erasure
|
|
while (!schemas.empty()) {
|
|
delete schemas.begin()->second;
|
|
}
|
|
}
|