Method get_decomposing_entity

src/ifcgeom/mapping/mapping.cpp:741–794

}

IfcUtil::IfcBaseEntity* mapping::get_decomposing_entity(const IfcUtil::IfcBaseEntity* inst, bool include_openings) {
    IfcSchema::IfcObjectDefinition* parent = 0;

    auto product = inst->as<IfcSchema::IfcProduct>();
    if (!product) {
        return parent;
    }

    /* In case of an opening element, parent to the RelatingBuildingElement */
    if (include_openings && product->declaration().is(IfcSchema::IfcOpeningElement::Class())) {
        IfcSchema::IfcOpeningElement* opening = (IfcSchema::IfcOpeningElement*)product;
        IfcSchema::IfcRelVoidsElement::list::ptr voids = opening->VoidsElements();
        if (voids->size()) {
            IfcSchema::IfcRelVoidsElement* ifc_void = *voids->begin();
            parent = ifc_void->RelatingBuildingElement();
        }
    } else if (product->declaration().is(IfcSchema::IfcElement::Class())) {
        IfcSchema::IfcElement* element = (IfcSchema::IfcElement*)product;
        IfcSchema::IfcRelFillsElement::list::ptr fills = element->FillsVoids();
        /* In case of a RelatedBuildingElement parent to the opening element */
        if (fills->size() && include_openings) {
            for (IfcSchema::IfcRelFillsElement::list::it it = fills->begin(); it != fills->end(); ++it) {
                IfcSchema::IfcRelFillsElement* fill = *it;
                IfcSchema::IfcObjectDefinition* ifc_objectdef = fill->RelatingOpeningElement();
                if (product == ifc_objectdef) continue;
                parent = ifc_objectdef;
            }
        }
        /* Else simply parent to the containing structure */
        if (!parent) {
            IfcSchema::IfcRelContainedInSpatialStructure::list::ptr parents = element->ContainedInStructure();
            if (parents->size()) {
                IfcSchema::IfcRelContainedInSpatialStructure* container = *parents->begin();
                parent = container->RelatingStructure();
            }
        }
    }

    /* Parent decompositions to the RelatingObject */
    if (!parent) {
        aggregate_of_instance::ptr parents = product->file_->getInverse(product->id(), (&IfcSchema::IfcRelAggregates::Class()), -1);
        parents->push(product->file_->getInverse(product->id(), (&IfcSchema::IfcRelNests::Class()), -1));
        for (aggregate_of_instance::it it = parents->begin(); it != parents->end(); ++it) {
            IfcSchema::IfcRelDecomposes* decompose = (*it)->as<IfcSchema::IfcRelDecomposes>();
            IfcUtil::IfcBaseEntity* ifc_objectdef;
                                                                                                                
            ifc_objectdef = get_RelatingObject(decompose);

            if (!ifc_objectdef || product == ifc_objectdef) continue;
            parent = ifc_objectdef->as<IfcSchema::IfcObjectDefinition>();
        }
    }
    return parent;
}

std::map<std::string, IfcUtil::IfcBaseEntity*> mapping::get_layers(IfcUtil::IfcBaseEntity* inst) {
    auto prod = inst->as<IfcSchema::IfcProduct>();