Method process_deletion_

src/ifcparse/IfcParse.cpp:2174–2267

}

void IfcFile::process_deletion_(IfcUtil::IfcBaseClass* entity) {

    aggregate_of_instance::ptr references = instances_by_reference(entity->id());

    // Alter entity instances with INVERSE relations to the entity being
    // deleted. This is necessary to maintain a valid IFC file, because
    // dangling references to it's entities name should be removed. At this
    // moment, inversely related instances affected by the removal of the
    // entity being deleted are not deleted themselves.
    if (references) {
        for (aggregate_of_instance::it iit = references->begin(); iit != references->end(); ++iit) {
            IfcUtil::IfcBaseEntity* related_instance = (IfcUtil::IfcBaseEntity*)*iit;

            if (std::find(batch_deletion_ids_.begin(), batch_deletion_ids_.end(), related_instance->id()) != batch_deletion_ids_.end()) {
                continue;
            }

            const auto& decl = related_instance->declaration();
            for (size_t i = 0; i < (decl.as_entity() ? decl.as_entity()->attribute_count() : 1); ++i) {
                auto attr = related_instance->get_attribute_value(i);
                if (attr.isNull()) {
                    continue;
                }

                IfcUtil::ArgumentType attr_type = attr.type();
                switch (attr_type) {
                case IfcUtil::Argument_ENTITY_INSTANCE: {
                    IfcUtil::IfcBaseClass* instance_attribute = attr;
                    if (instance_attribute == entity) {
                        related_instance->set_attribute_value(i, Blank{});
                    }
                } break;
                case IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE: {
                    aggregate_of_instance::ptr instance_list = attr;
                    if (instance_list->contains(entity)) {
                        instance_list->remove(entity);
                        if ((instance_list->size() == 0U) && related_instance->declaration().as_entity()->attribute_by_index(i)->optional()) {
                            // @todo we can also check the lower bound of the attribute type before setting to null.
                            related_instance->set_attribute_value(i, Blank{});
                        } else {
                            related_instance->set_attribute_value(i, instance_list);
                        }
                    }
                } break;
                case IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_ENTITY_INSTANCE: {
                    aggregate_of_aggregate_of_instance::ptr instance_list_list = attr;
                    if (instance_list_list->contains(entity)) {
                        aggregate_of_aggregate_of_instance::ptr new_list(new aggregate_of_aggregate_of_instance);
                        for (aggregate_of_aggregate_of_instance::outer_it it = instance_list_list->begin(); it != instance_list_list->end(); ++it) {
                            std::vector<IfcUtil::IfcBaseClass*> instances = *it;
                            std::vector<IfcUtil::IfcBaseClass*>::iterator jt;
                            while ((jt = std::find(instances.begin(), instances.end(), entity)) != instances.end()) {
                                instances.erase(jt);
                            }
                            new_list->push(instances);
                        }
                        related_instance->set_attribute_value(i, new_list);
                    }