void IfcRelVoidsElement::unlinkSelf() { IfcRelDecomposes::unlinkSelf(); if( m_RelatedOpeningElement ) { shared_ptr<IfcRelVoidsElement> self_candidate( m_RelatedOpeningElement->m_VoidsElements_inverse ); if( self_candidate->getId() == this->getId() ) { weak_ptr<IfcRelVoidsElement>& self_candidate_weak = m_RelatedOpeningElement->m_VoidsElements_inverse; self_candidate_weak.reset(); } } if( m_RelatingBuildingElement ) { std::vector<weak_ptr<IfcRelVoidsElement> >& HasOpenings_inverse = m_RelatingBuildingElement->m_HasOpenings_inverse; std::vector<weak_ptr<IfcRelVoidsElement> >::iterator it_HasOpenings_inverse; for( it_HasOpenings_inverse = HasOpenings_inverse.begin(); it_HasOpenings_inverse != HasOpenings_inverse.end(); ++it_HasOpenings_inverse) { shared_ptr<IfcRelVoidsElement> self_candidate( *it_HasOpenings_inverse ); if( self_candidate->getId() == this->getId() ) { HasOpenings_inverse.erase( it_HasOpenings_inverse ); break; } } } }
void IfcRelAssignsToResource::unlinkSelf() { IfcRelAssigns::unlinkSelf(); shared_ptr<IfcResource> RelatingResource_IfcResource = dynamic_pointer_cast<IfcResource>( m_RelatingResource ); if( RelatingResource_IfcResource ) { std::vector<weak_ptr<IfcRelAssignsToResource> >& ResourceOf_inverse = RelatingResource_IfcResource->m_ResourceOf_inverse; std::vector<weak_ptr<IfcRelAssignsToResource> >::iterator it_ResourceOf_inverse; for( it_ResourceOf_inverse = ResourceOf_inverse.begin(); it_ResourceOf_inverse != ResourceOf_inverse.end(); ++it_ResourceOf_inverse) { shared_ptr<IfcRelAssignsToResource> self_candidate( *it_ResourceOf_inverse ); if( self_candidate->getId() == this->getId() ) { ResourceOf_inverse.erase( it_ResourceOf_inverse ); break; } } } shared_ptr<IfcTypeResource> RelatingResource_IfcTypeResource = dynamic_pointer_cast<IfcTypeResource>( m_RelatingResource ); if( RelatingResource_IfcTypeResource ) { std::vector<weak_ptr<IfcRelAssignsToResource> >& ResourceOf_inverse = RelatingResource_IfcTypeResource->m_ResourceOf_inverse; std::vector<weak_ptr<IfcRelAssignsToResource> >::iterator it_ResourceOf_inverse; for( it_ResourceOf_inverse = ResourceOf_inverse.begin(); it_ResourceOf_inverse != ResourceOf_inverse.end(); ++it_ResourceOf_inverse) { shared_ptr<IfcRelAssignsToResource> self_candidate( *it_ResourceOf_inverse ); if( self_candidate->getId() == this->getId() ) { ResourceOf_inverse.erase( it_ResourceOf_inverse ); break; } } } }
void IfcProduct::unlinkSelf() { IfcObject::unlinkSelf(); if( m_ObjectPlacement ) { std::vector<weak_ptr<IfcProduct> >& PlacesObject_inverse = m_ObjectPlacement->m_PlacesObject_inverse; std::vector<weak_ptr<IfcProduct> >::iterator it_PlacesObject_inverse; for( it_PlacesObject_inverse = PlacesObject_inverse.begin(); it_PlacesObject_inverse != PlacesObject_inverse.end(); ++it_PlacesObject_inverse) { shared_ptr<IfcProduct> self_candidate( *it_PlacesObject_inverse ); if( self_candidate->getId() == this->getId() ) { PlacesObject_inverse.erase( it_PlacesObject_inverse ); break; } } } shared_ptr<IfcProductDefinitionShape> Representation_IfcProductDefinitionShape = dynamic_pointer_cast<IfcProductDefinitionShape>( m_Representation ); if( Representation_IfcProductDefinitionShape ) { std::vector<weak_ptr<IfcProduct> >& ShapeOfProduct_inverse = Representation_IfcProductDefinitionShape->m_ShapeOfProduct_inverse; std::vector<weak_ptr<IfcProduct> >::iterator it_ShapeOfProduct_inverse; for( it_ShapeOfProduct_inverse = ShapeOfProduct_inverse.begin(); it_ShapeOfProduct_inverse != ShapeOfProduct_inverse.end(); ++it_ShapeOfProduct_inverse) { shared_ptr<IfcProduct> self_candidate( *it_ShapeOfProduct_inverse ); if( self_candidate->getId() == this->getId() ) { ShapeOfProduct_inverse.erase( it_ShapeOfProduct_inverse ); break; } } } }
void IfcPersonAndOrganization::unlinkSelf() { if( m_TheOrganization ) { std::vector<weak_ptr<IfcPersonAndOrganization> >& Engages_inverse = m_TheOrganization->m_Engages_inverse; std::vector<weak_ptr<IfcPersonAndOrganization> >::iterator it_Engages_inverse; for( it_Engages_inverse = Engages_inverse.begin(); it_Engages_inverse != Engages_inverse.end(); ++it_Engages_inverse) { shared_ptr<IfcPersonAndOrganization> self_candidate( *it_Engages_inverse ); if( self_candidate->getId() == this->getId() ) { Engages_inverse.erase( it_Engages_inverse ); break; } } } if( m_ThePerson ) { std::vector<weak_ptr<IfcPersonAndOrganization> >& EngagedIn_inverse = m_ThePerson->m_EngagedIn_inverse; std::vector<weak_ptr<IfcPersonAndOrganization> >::iterator it_EngagedIn_inverse; for( it_EngagedIn_inverse = EngagedIn_inverse.begin(); it_EngagedIn_inverse != EngagedIn_inverse.end(); ++it_EngagedIn_inverse) { shared_ptr<IfcPersonAndOrganization> self_candidate( *it_EngagedIn_inverse ); if( self_candidate->getId() == this->getId() ) { EngagedIn_inverse.erase( it_EngagedIn_inverse ); break; } } } }
void IfcRelDefinesByType::unlinkSelf() { IfcRelDefines::unlinkSelf(); for( int i=0; i<m_RelatedObjects.size(); ++i ) { if( m_RelatedObjects[i] ) { std::vector<weak_ptr<IfcRelDefinesByType> >& IsTypedBy_inverse = m_RelatedObjects[i]->m_IsTypedBy_inverse; std::vector<weak_ptr<IfcRelDefinesByType> >::iterator it_IsTypedBy_inverse; for( it_IsTypedBy_inverse = IsTypedBy_inverse.begin(); it_IsTypedBy_inverse != IsTypedBy_inverse.end(); ++it_IsTypedBy_inverse) { shared_ptr<IfcRelDefinesByType> self_candidate( *it_IsTypedBy_inverse ); if( self_candidate->getId() == this->getId() ) { IsTypedBy_inverse.erase( it_IsTypedBy_inverse ); break; } } } } if( m_RelatingType ) { std::vector<weak_ptr<IfcRelDefinesByType> >& Types_inverse = m_RelatingType->m_Types_inverse; std::vector<weak_ptr<IfcRelDefinesByType> >::iterator it_Types_inverse; for( it_Types_inverse = Types_inverse.begin(); it_Types_inverse != Types_inverse.end(); ++it_Types_inverse) { shared_ptr<IfcRelDefinesByType> self_candidate( *it_Types_inverse ); if( self_candidate->getId() == this->getId() ) { Types_inverse.erase( it_Types_inverse ); break; } } } }
void IfcRelFillsElement::unlinkSelf() { IfcRelConnects::unlinkSelf(); if( m_RelatedBuildingElement ) { std::vector<weak_ptr<IfcRelFillsElement> >& FillsVoids_inverse = m_RelatedBuildingElement->m_FillsVoids_inverse; std::vector<weak_ptr<IfcRelFillsElement> >::iterator it_FillsVoids_inverse; for( it_FillsVoids_inverse = FillsVoids_inverse.begin(); it_FillsVoids_inverse != FillsVoids_inverse.end(); ++it_FillsVoids_inverse) { shared_ptr<IfcRelFillsElement> self_candidate( *it_FillsVoids_inverse ); if( self_candidate->getId() == this->getId() ) { FillsVoids_inverse.erase( it_FillsVoids_inverse ); break; } } } if( m_RelatingOpeningElement ) { std::vector<weak_ptr<IfcRelFillsElement> >& HasFillings_inverse = m_RelatingOpeningElement->m_HasFillings_inverse; std::vector<weak_ptr<IfcRelFillsElement> >::iterator it_HasFillings_inverse; for( it_HasFillings_inverse = HasFillings_inverse.begin(); it_HasFillings_inverse != HasFillings_inverse.end(); ++it_HasFillings_inverse) { shared_ptr<IfcRelFillsElement> self_candidate( *it_HasFillings_inverse ); if( self_candidate->getId() == this->getId() ) { HasFillings_inverse.erase( it_HasFillings_inverse ); break; } } } }
void IfcRelConnectsPortToElement::unlinkSelf() { IfcRelConnects::unlinkSelf(); if( m_RelatedElement ) { std::vector<weak_ptr<IfcRelConnectsPortToElement> >& HasPorts_inverse = m_RelatedElement->m_HasPorts_inverse; std::vector<weak_ptr<IfcRelConnectsPortToElement> >::iterator it_HasPorts_inverse; for( it_HasPorts_inverse = HasPorts_inverse.begin(); it_HasPorts_inverse != HasPorts_inverse.end(); ++it_HasPorts_inverse) { shared_ptr<IfcRelConnectsPortToElement> self_candidate( *it_HasPorts_inverse ); if( self_candidate->getId() == this->getId() ) { HasPorts_inverse.erase( it_HasPorts_inverse ); break; } } } if( m_RelatingPort ) { std::vector<weak_ptr<IfcRelConnectsPortToElement> >& ContainedIn_inverse = m_RelatingPort->m_ContainedIn_inverse; std::vector<weak_ptr<IfcRelConnectsPortToElement> >::iterator it_ContainedIn_inverse; for( it_ContainedIn_inverse = ContainedIn_inverse.begin(); it_ContainedIn_inverse != ContainedIn_inverse.end(); ++it_ContainedIn_inverse) { shared_ptr<IfcRelConnectsPortToElement> self_candidate( *it_ContainedIn_inverse ); if( self_candidate->getId() == this->getId() ) { ContainedIn_inverse.erase( it_ContainedIn_inverse ); break; } } } }
void IfcRelConnectsElements::unlinkSelf() { IfcRelConnects::unlinkSelf(); if( m_RelatedElement ) { std::vector<weak_ptr<IfcRelConnectsElements> >& ConnectedFrom_inverse = m_RelatedElement->m_ConnectedFrom_inverse; std::vector<weak_ptr<IfcRelConnectsElements> >::iterator it_ConnectedFrom_inverse; for( it_ConnectedFrom_inverse = ConnectedFrom_inverse.begin(); it_ConnectedFrom_inverse != ConnectedFrom_inverse.end(); ++it_ConnectedFrom_inverse) { shared_ptr<IfcRelConnectsElements> self_candidate( *it_ConnectedFrom_inverse ); if( self_candidate->getId() == this->getId() ) { ConnectedFrom_inverse.erase( it_ConnectedFrom_inverse ); break; } } } if( m_RelatingElement ) { std::vector<weak_ptr<IfcRelConnectsElements> >& ConnectedTo_inverse = m_RelatingElement->m_ConnectedTo_inverse; std::vector<weak_ptr<IfcRelConnectsElements> >::iterator it_ConnectedTo_inverse; for( it_ConnectedTo_inverse = ConnectedTo_inverse.begin(); it_ConnectedTo_inverse != ConnectedTo_inverse.end(); ++it_ConnectedTo_inverse) { shared_ptr<IfcRelConnectsElements> self_candidate( *it_ConnectedTo_inverse ); if( self_candidate->getId() == this->getId() ) { ConnectedTo_inverse.erase( it_ConnectedTo_inverse ); break; } } } }
void IfcRelNests::unlinkSelf() { IfcRelDecomposes::unlinkSelf(); for( int i=0; i<m_RelatedObjects.size(); ++i ) { if( m_RelatedObjects[i] ) { std::vector<weak_ptr<IfcRelNests> >& Nests_inverse = m_RelatedObjects[i]->m_Nests_inverse; std::vector<weak_ptr<IfcRelNests> >::iterator it_Nests_inverse; for( it_Nests_inverse = Nests_inverse.begin(); it_Nests_inverse != Nests_inverse.end(); ++it_Nests_inverse) { shared_ptr<IfcRelNests> self_candidate( *it_Nests_inverse ); if( self_candidate->getId() == this->getId() ) { Nests_inverse.erase( it_Nests_inverse ); break; } } } } if( m_RelatingObject ) { std::vector<weak_ptr<IfcRelNests> >& IsNestedBy_inverse = m_RelatingObject->m_IsNestedBy_inverse; std::vector<weak_ptr<IfcRelNests> >::iterator it_IsNestedBy_inverse; for( it_IsNestedBy_inverse = IsNestedBy_inverse.begin(); it_IsNestedBy_inverse != IsNestedBy_inverse.end(); ++it_IsNestedBy_inverse) { shared_ptr<IfcRelNests> self_candidate( *it_IsNestedBy_inverse ); if( self_candidate->getId() == this->getId() ) { IsNestedBy_inverse.erase( it_IsNestedBy_inverse ); break; } } } }
void IfcRelSpaceBoundary::unlinkSelf() { IfcRelConnects::unlinkSelf(); if( m_RelatedBuildingElement ) { std::vector<weak_ptr<IfcRelSpaceBoundary> >& ProvidesBoundaries_inverse = m_RelatedBuildingElement->m_ProvidesBoundaries_inverse; std::vector<weak_ptr<IfcRelSpaceBoundary> >::iterator it_ProvidesBoundaries_inverse; for( it_ProvidesBoundaries_inverse = ProvidesBoundaries_inverse.begin(); it_ProvidesBoundaries_inverse != ProvidesBoundaries_inverse.end(); ++it_ProvidesBoundaries_inverse) { shared_ptr<IfcRelSpaceBoundary> self_candidate( *it_ProvidesBoundaries_inverse ); if( self_candidate->getId() == this->getId() ) { ProvidesBoundaries_inverse.erase( it_ProvidesBoundaries_inverse ); break; } } } if( m_RelatingSpace ) { std::vector<weak_ptr<IfcRelSpaceBoundary> >& BoundedBy_inverse = m_RelatingSpace->m_BoundedBy_inverse; std::vector<weak_ptr<IfcRelSpaceBoundary> >::iterator it_BoundedBy_inverse; for( it_BoundedBy_inverse = BoundedBy_inverse.begin(); it_BoundedBy_inverse != BoundedBy_inverse.end(); ++it_BoundedBy_inverse) { shared_ptr<IfcRelSpaceBoundary> self_candidate( *it_BoundedBy_inverse ); if( self_candidate->getId() == this->getId() ) { BoundedBy_inverse.erase( it_BoundedBy_inverse ); break; } } } }
void IfcRelAssociatesMaterial::unlinkSelf() { IfcRelAssociates::unlinkSelf(); shared_ptr<IfcMaterialDefinition> RelatingMaterial_IfcMaterialDefinition = dynamic_pointer_cast<IfcMaterialDefinition>( m_RelatingMaterial ); if( RelatingMaterial_IfcMaterialDefinition ) { std::vector<weak_ptr<IfcRelAssociatesMaterial> >& AssociatedTo_inverse = RelatingMaterial_IfcMaterialDefinition->m_AssociatedTo_inverse; std::vector<weak_ptr<IfcRelAssociatesMaterial> >::iterator it_AssociatedTo_inverse; for( it_AssociatedTo_inverse = AssociatedTo_inverse.begin(); it_AssociatedTo_inverse != AssociatedTo_inverse.end(); ++it_AssociatedTo_inverse) { shared_ptr<IfcRelAssociatesMaterial> self_candidate( *it_AssociatedTo_inverse ); if( self_candidate->getId() == this->getId() ) { AssociatedTo_inverse.erase( it_AssociatedTo_inverse ); break; } } } shared_ptr<IfcMaterialUsageDefinition> RelatingMaterial_IfcMaterialUsageDefinition = dynamic_pointer_cast<IfcMaterialUsageDefinition>( m_RelatingMaterial ); if( RelatingMaterial_IfcMaterialUsageDefinition ) { std::vector<weak_ptr<IfcRelAssociatesMaterial> >& AssociatedTo_inverse = RelatingMaterial_IfcMaterialUsageDefinition->m_AssociatedTo_inverse; std::vector<weak_ptr<IfcRelAssociatesMaterial> >::iterator it_AssociatedTo_inverse; for( it_AssociatedTo_inverse = AssociatedTo_inverse.begin(); it_AssociatedTo_inverse != AssociatedTo_inverse.end(); ++it_AssociatedTo_inverse) { shared_ptr<IfcRelAssociatesMaterial> self_candidate( *it_AssociatedTo_inverse ); if( self_candidate->getId() == this->getId() ) { AssociatedTo_inverse.erase( it_AssociatedTo_inverse ); break; } } } }
void IfcDocumentInformationRelationship::unlinkSelf() { IfcResourceLevelRelationship::unlinkSelf(); for( int i=0; i<m_RelatedDocuments.size(); ++i ) { if( m_RelatedDocuments[i] ) { std::vector<weak_ptr<IfcDocumentInformationRelationship> >& IsPointedTo_inverse = m_RelatedDocuments[i]->m_IsPointedTo_inverse; std::vector<weak_ptr<IfcDocumentInformationRelationship> >::iterator it_IsPointedTo_inverse; for( it_IsPointedTo_inverse = IsPointedTo_inverse.begin(); it_IsPointedTo_inverse != IsPointedTo_inverse.end(); ++it_IsPointedTo_inverse) { shared_ptr<IfcDocumentInformationRelationship> self_candidate( *it_IsPointedTo_inverse ); if( self_candidate->getId() == this->getId() ) { IsPointedTo_inverse.erase( it_IsPointedTo_inverse ); break; } } } } if( m_RelatingDocument ) { std::vector<weak_ptr<IfcDocumentInformationRelationship> >& IsPointer_inverse = m_RelatingDocument->m_IsPointer_inverse; std::vector<weak_ptr<IfcDocumentInformationRelationship> >::iterator it_IsPointer_inverse; for( it_IsPointer_inverse = IsPointer_inverse.begin(); it_IsPointer_inverse != IsPointer_inverse.end(); ++it_IsPointer_inverse) { shared_ptr<IfcDocumentInformationRelationship> self_candidate( *it_IsPointer_inverse ); if( self_candidate->getId() == this->getId() ) { IsPointer_inverse.erase( it_IsPointer_inverse ); break; } } } }
void IfcRelAssociatesLibrary::unlinkSelf() { IfcRelAssociates::unlinkSelf(); shared_ptr<IfcLibraryInformation> RelatingLibrary_IfcLibraryInformation = dynamic_pointer_cast<IfcLibraryInformation>( m_RelatingLibrary ); if( RelatingLibrary_IfcLibraryInformation ) { std::vector<weak_ptr<IfcRelAssociatesLibrary> >& LibraryInfoForObjects_inverse = RelatingLibrary_IfcLibraryInformation->m_LibraryInfoForObjects_inverse; std::vector<weak_ptr<IfcRelAssociatesLibrary> >::iterator it_LibraryInfoForObjects_inverse; for( it_LibraryInfoForObjects_inverse = LibraryInfoForObjects_inverse.begin(); it_LibraryInfoForObjects_inverse != LibraryInfoForObjects_inverse.end(); ++it_LibraryInfoForObjects_inverse) { shared_ptr<IfcRelAssociatesLibrary> self_candidate( *it_LibraryInfoForObjects_inverse ); if( self_candidate->getId() == this->getId() ) { LibraryInfoForObjects_inverse.erase( it_LibraryInfoForObjects_inverse ); break; } } } shared_ptr<IfcLibraryReference> RelatingLibrary_IfcLibraryReference = dynamic_pointer_cast<IfcLibraryReference>( m_RelatingLibrary ); if( RelatingLibrary_IfcLibraryReference ) { std::vector<weak_ptr<IfcRelAssociatesLibrary> >& LibraryRefForObjects_inverse = RelatingLibrary_IfcLibraryReference->m_LibraryRefForObjects_inverse; std::vector<weak_ptr<IfcRelAssociatesLibrary> >::iterator it_LibraryRefForObjects_inverse; for( it_LibraryRefForObjects_inverse = LibraryRefForObjects_inverse.begin(); it_LibraryRefForObjects_inverse != LibraryRefForObjects_inverse.end(); ++it_LibraryRefForObjects_inverse) { shared_ptr<IfcRelAssociatesLibrary> self_candidate( *it_LibraryRefForObjects_inverse ); if( self_candidate->getId() == this->getId() ) { LibraryRefForObjects_inverse.erase( it_LibraryRefForObjects_inverse ); break; } } } }
void IfcRelConnectsStructuralActivity::unlinkSelf() { IfcRelConnects::unlinkSelf(); if( m_RelatedStructuralActivity ) { std::vector<weak_ptr<IfcRelConnectsStructuralActivity> >& AssignedToStructuralItem_inverse = m_RelatedStructuralActivity->m_AssignedToStructuralItem_inverse; std::vector<weak_ptr<IfcRelConnectsStructuralActivity> >::iterator it_AssignedToStructuralItem_inverse; for( it_AssignedToStructuralItem_inverse = AssignedToStructuralItem_inverse.begin(); it_AssignedToStructuralItem_inverse != AssignedToStructuralItem_inverse.end(); ++it_AssignedToStructuralItem_inverse) { shared_ptr<IfcRelConnectsStructuralActivity> self_candidate( *it_AssignedToStructuralItem_inverse ); if( self_candidate->getId() == this->getId() ) { AssignedToStructuralItem_inverse.erase( it_AssignedToStructuralItem_inverse ); break; } } } shared_ptr<IfcStructuralItem> RelatingElement_IfcStructuralItem = dynamic_pointer_cast<IfcStructuralItem>( m_RelatingElement ); if( RelatingElement_IfcStructuralItem ) { std::vector<weak_ptr<IfcRelConnectsStructuralActivity> >& AssignedStructuralActivity_inverse = RelatingElement_IfcStructuralItem->m_AssignedStructuralActivity_inverse; std::vector<weak_ptr<IfcRelConnectsStructuralActivity> >::iterator it_AssignedStructuralActivity_inverse; for( it_AssignedStructuralActivity_inverse = AssignedStructuralActivity_inverse.begin(); it_AssignedStructuralActivity_inverse != AssignedStructuralActivity_inverse.end(); ++it_AssignedStructuralActivity_inverse) { shared_ptr<IfcRelConnectsStructuralActivity> self_candidate( *it_AssignedStructuralActivity_inverse ); if( self_candidate->getId() == this->getId() ) { AssignedStructuralActivity_inverse.erase( it_AssignedStructuralActivity_inverse ); break; } } } }
void IfcRelInterferesElements::unlinkSelf() { IfcRelConnects::unlinkSelf(); if( m_RelatedElement ) { std::vector<weak_ptr<IfcRelInterferesElements> >& IsInterferedByElements_inverse = m_RelatedElement->m_IsInterferedByElements_inverse; std::vector<weak_ptr<IfcRelInterferesElements> >::iterator it_IsInterferedByElements_inverse; for( it_IsInterferedByElements_inverse = IsInterferedByElements_inverse.begin(); it_IsInterferedByElements_inverse != IsInterferedByElements_inverse.end(); ++it_IsInterferedByElements_inverse) { shared_ptr<IfcRelInterferesElements> self_candidate( *it_IsInterferedByElements_inverse ); if( self_candidate->getId() == this->getId() ) { IsInterferedByElements_inverse.erase( it_IsInterferedByElements_inverse ); break; } } } if( m_RelatingElement ) { std::vector<weak_ptr<IfcRelInterferesElements> >& InterferesElements_inverse = m_RelatingElement->m_InterferesElements_inverse; std::vector<weak_ptr<IfcRelInterferesElements> >::iterator it_InterferesElements_inverse; for( it_InterferesElements_inverse = InterferesElements_inverse.begin(); it_InterferesElements_inverse != InterferesElements_inverse.end(); ++it_InterferesElements_inverse) { shared_ptr<IfcRelInterferesElements> self_candidate( *it_InterferesElements_inverse ); if( self_candidate->getId() == this->getId() ) { InterferesElements_inverse.erase( it_InterferesElements_inverse ); break; } } } }
void IfcRelSequence::unlinkSelf() { IfcRelConnects::unlinkSelf(); if( m_RelatedProcess ) { std::vector<weak_ptr<IfcRelSequence> >& IsSuccessorFrom_inverse = m_RelatedProcess->m_IsSuccessorFrom_inverse; std::vector<weak_ptr<IfcRelSequence> >::iterator it_IsSuccessorFrom_inverse; for( it_IsSuccessorFrom_inverse = IsSuccessorFrom_inverse.begin(); it_IsSuccessorFrom_inverse != IsSuccessorFrom_inverse.end(); ++it_IsSuccessorFrom_inverse) { shared_ptr<IfcRelSequence> self_candidate( *it_IsSuccessorFrom_inverse ); if( self_candidate->getId() == this->getId() ) { IsSuccessorFrom_inverse.erase( it_IsSuccessorFrom_inverse ); break; } } } if( m_RelatingProcess ) { std::vector<weak_ptr<IfcRelSequence> >& IsPredecessorTo_inverse = m_RelatingProcess->m_IsPredecessorTo_inverse; std::vector<weak_ptr<IfcRelSequence> >::iterator it_IsPredecessorTo_inverse; for( it_IsPredecessorTo_inverse = IsPredecessorTo_inverse.begin(); it_IsPredecessorTo_inverse != IsPredecessorTo_inverse.end(); ++it_IsPredecessorTo_inverse) { shared_ptr<IfcRelSequence> self_candidate( *it_IsPredecessorTo_inverse ); if( self_candidate->getId() == this->getId() ) { IsPredecessorTo_inverse.erase( it_IsPredecessorTo_inverse ); break; } } } }
void IfcMaterialRelationship::unlinkSelf() { IfcResourceLevelRelationship::unlinkSelf(); for( int i=0; i<m_RelatedMaterials.size(); ++i ) { if( m_RelatedMaterials[i] ) { std::vector<weak_ptr<IfcMaterialRelationship> >& IsRelatedWith_inverse = m_RelatedMaterials[i]->m_IsRelatedWith_inverse; std::vector<weak_ptr<IfcMaterialRelationship> >::iterator it_IsRelatedWith_inverse; for( it_IsRelatedWith_inverse = IsRelatedWith_inverse.begin(); it_IsRelatedWith_inverse != IsRelatedWith_inverse.end(); ++it_IsRelatedWith_inverse) { shared_ptr<IfcMaterialRelationship> self_candidate( *it_IsRelatedWith_inverse ); if( self_candidate->getId() == this->getId() ) { IsRelatedWith_inverse.erase( it_IsRelatedWith_inverse ); break; } } } } if( m_RelatingMaterial ) { std::vector<weak_ptr<IfcMaterialRelationship> >& RelatesTo_inverse = m_RelatingMaterial->m_RelatesTo_inverse; std::vector<weak_ptr<IfcMaterialRelationship> >::iterator it_RelatesTo_inverse; for( it_RelatesTo_inverse = RelatesTo_inverse.begin(); it_RelatesTo_inverse != RelatesTo_inverse.end(); ++it_RelatesTo_inverse) { shared_ptr<IfcMaterialRelationship> self_candidate( *it_RelatesTo_inverse ); if( self_candidate->getId() == this->getId() ) { RelatesTo_inverse.erase( it_RelatesTo_inverse ); break; } } } }
void IfcRelDefinesByProperties::unlinkFromInverseCounterparts() { IfcRelDefines::unlinkFromInverseCounterparts(); for( size_t i=0; i<m_RelatedObjects.size(); ++i ) { shared_ptr<IfcContext> RelatedObjects_IfcContext = dynamic_pointer_cast<IfcContext>( m_RelatedObjects[i] ); if( RelatedObjects_IfcContext ) { std::vector<weak_ptr<IfcRelDefinesByProperties> >& IsDefinedBy_inverse = RelatedObjects_IfcContext->m_IsDefinedBy_inverse; for( auto it_IsDefinedBy_inverse = IsDefinedBy_inverse.begin(); it_IsDefinedBy_inverse != IsDefinedBy_inverse.end(); ) { shared_ptr<IfcRelDefinesByProperties> self_candidate( *it_IsDefinedBy_inverse ); if( self_candidate.get() == this ) { it_IsDefinedBy_inverse= IsDefinedBy_inverse.erase( it_IsDefinedBy_inverse ); } else { ++it_IsDefinedBy_inverse; } } } shared_ptr<IfcObject> RelatedObjects_IfcObject = dynamic_pointer_cast<IfcObject>( m_RelatedObjects[i] ); if( RelatedObjects_IfcObject ) { std::vector<weak_ptr<IfcRelDefinesByProperties> >& IsDefinedBy_inverse = RelatedObjects_IfcObject->m_IsDefinedBy_inverse; for( auto it_IsDefinedBy_inverse = IsDefinedBy_inverse.begin(); it_IsDefinedBy_inverse != IsDefinedBy_inverse.end(); ) { shared_ptr<IfcRelDefinesByProperties> self_candidate( *it_IsDefinedBy_inverse ); if( self_candidate.get() == this ) { it_IsDefinedBy_inverse= IsDefinedBy_inverse.erase( it_IsDefinedBy_inverse ); } else { ++it_IsDefinedBy_inverse; } } } } shared_ptr<IfcPropertySetDefinition> RelatingPropertyDefinition_IfcPropertySetDefinition = dynamic_pointer_cast<IfcPropertySetDefinition>( m_RelatingPropertyDefinition ); if( RelatingPropertyDefinition_IfcPropertySetDefinition ) { std::vector<weak_ptr<IfcRelDefinesByProperties> >& DefinesOccurrence_inverse = RelatingPropertyDefinition_IfcPropertySetDefinition->m_DefinesOccurrence_inverse; for( auto it_DefinesOccurrence_inverse = DefinesOccurrence_inverse.begin(); it_DefinesOccurrence_inverse != DefinesOccurrence_inverse.end(); ) { shared_ptr<IfcRelDefinesByProperties> self_candidate( *it_DefinesOccurrence_inverse ); if( self_candidate.get() == this ) { it_DefinesOccurrence_inverse= DefinesOccurrence_inverse.erase( it_DefinesOccurrence_inverse ); } else { ++it_DefinesOccurrence_inverse; } } } }
void IfcShapeAspect::unlinkFromInverseCounterparts() { shared_ptr<IfcProductDefinitionShape> PartOfProductDefinitionShape_IfcProductDefinitionShape = dynamic_pointer_cast<IfcProductDefinitionShape>( m_PartOfProductDefinitionShape ); if( PartOfProductDefinitionShape_IfcProductDefinitionShape ) { std::vector<weak_ptr<IfcShapeAspect> >& HasShapeAspects_inverse = PartOfProductDefinitionShape_IfcProductDefinitionShape->m_HasShapeAspects_inverse; for( auto it_HasShapeAspects_inverse = HasShapeAspects_inverse.begin(); it_HasShapeAspects_inverse != HasShapeAspects_inverse.end(); ) { shared_ptr<IfcShapeAspect> self_candidate( *it_HasShapeAspects_inverse ); if( self_candidate.get() == this ) { it_HasShapeAspects_inverse= HasShapeAspects_inverse.erase( it_HasShapeAspects_inverse ); } else { ++it_HasShapeAspects_inverse; } } } shared_ptr<IfcRepresentationMap> PartOfProductDefinitionShape_IfcRepresentationMap = dynamic_pointer_cast<IfcRepresentationMap>( m_PartOfProductDefinitionShape ); if( PartOfProductDefinitionShape_IfcRepresentationMap ) { std::vector<weak_ptr<IfcShapeAspect> >& HasShapeAspects_inverse = PartOfProductDefinitionShape_IfcRepresentationMap->m_HasShapeAspects_inverse; for( auto it_HasShapeAspects_inverse = HasShapeAspects_inverse.begin(); it_HasShapeAspects_inverse != HasShapeAspects_inverse.end(); ) { shared_ptr<IfcShapeAspect> self_candidate( *it_HasShapeAspects_inverse ); if( self_candidate.get() == this ) { it_HasShapeAspects_inverse= HasShapeAspects_inverse.erase( it_HasShapeAspects_inverse ); } else { ++it_HasShapeAspects_inverse; } } } for( size_t i=0; i<m_ShapeRepresentations.size(); ++i ) { if( m_ShapeRepresentations[i] ) { std::vector<weak_ptr<IfcShapeAspect> >& OfShapeAspect_inverse = m_ShapeRepresentations[i]->m_OfShapeAspect_inverse; for( auto it_OfShapeAspect_inverse = OfShapeAspect_inverse.begin(); it_OfShapeAspect_inverse != OfShapeAspect_inverse.end(); ) { shared_ptr<IfcShapeAspect> self_candidate( *it_OfShapeAspect_inverse ); if( self_candidate.get() == this ) { it_OfShapeAspect_inverse= OfShapeAspect_inverse.erase( it_OfShapeAspect_inverse ); } else { ++it_OfShapeAspect_inverse; } } } } }
void IfcStructuralAnalysisModel::unlinkFromInverseCounterparts() { IfcSystem::unlinkFromInverseCounterparts(); for( size_t i=0; i<m_HasResults.size(); ++i ) { if( m_HasResults[i] ) { std::vector<weak_ptr<IfcStructuralAnalysisModel> >& ResultGroupFor_inverse = m_HasResults[i]->m_ResultGroupFor_inverse; for( auto it_ResultGroupFor_inverse = ResultGroupFor_inverse.begin(); it_ResultGroupFor_inverse != ResultGroupFor_inverse.end(); ) { weak_ptr<IfcStructuralAnalysisModel> self_candidate_weak = *it_ResultGroupFor_inverse; if( self_candidate_weak.expired() ) { ++it_ResultGroupFor_inverse; continue; } shared_ptr<IfcStructuralAnalysisModel> self_candidate( *it_ResultGroupFor_inverse ); if( self_candidate.get() == this ) { it_ResultGroupFor_inverse= ResultGroupFor_inverse.erase( it_ResultGroupFor_inverse ); } else { ++it_ResultGroupFor_inverse; } } } } for( size_t i=0; i<m_LoadedBy.size(); ++i ) { if( m_LoadedBy[i] ) { std::vector<weak_ptr<IfcStructuralAnalysisModel> >& LoadGroupFor_inverse = m_LoadedBy[i]->m_LoadGroupFor_inverse; for( auto it_LoadGroupFor_inverse = LoadGroupFor_inverse.begin(); it_LoadGroupFor_inverse != LoadGroupFor_inverse.end(); ) { weak_ptr<IfcStructuralAnalysisModel> self_candidate_weak = *it_LoadGroupFor_inverse; if( self_candidate_weak.expired() ) { ++it_LoadGroupFor_inverse; continue; } shared_ptr<IfcStructuralAnalysisModel> self_candidate( *it_LoadGroupFor_inverse ); if( self_candidate.get() == this ) { it_LoadGroupFor_inverse= LoadGroupFor_inverse.erase( it_LoadGroupFor_inverse ); } else { ++it_LoadGroupFor_inverse; } } } } }
void IfcResourceConstraintRelationship::unlinkFromInverseCounterparts() { IfcResourceLevelRelationship::unlinkFromInverseCounterparts(); for( size_t i=0; i<m_RelatedResourceObjects.size(); ++i ) { shared_ptr<IfcProperty> RelatedResourceObjects_IfcProperty = dynamic_pointer_cast<IfcProperty>( m_RelatedResourceObjects[i] ); if( RelatedResourceObjects_IfcProperty ) { std::vector<weak_ptr<IfcResourceConstraintRelationship> >& HasConstraints_inverse = RelatedResourceObjects_IfcProperty->m_HasConstraints_inverse; for( auto it_HasConstraints_inverse = HasConstraints_inverse.begin(); it_HasConstraints_inverse != HasConstraints_inverse.end(); ) { weak_ptr<IfcResourceConstraintRelationship> self_candidate_weak = *it_HasConstraints_inverse; if( self_candidate_weak.expired() ) { ++it_HasConstraints_inverse; continue; } shared_ptr<IfcResourceConstraintRelationship> self_candidate( *it_HasConstraints_inverse ); if( self_candidate.get() == this ) { it_HasConstraints_inverse= HasConstraints_inverse.erase( it_HasConstraints_inverse ); } else { ++it_HasConstraints_inverse; } } } } if( m_RelatingConstraint ) { std::vector<weak_ptr<IfcResourceConstraintRelationship> >& PropertiesForConstraint_inverse = m_RelatingConstraint->m_PropertiesForConstraint_inverse; for( auto it_PropertiesForConstraint_inverse = PropertiesForConstraint_inverse.begin(); it_PropertiesForConstraint_inverse != PropertiesForConstraint_inverse.end(); ) { weak_ptr<IfcResourceConstraintRelationship> self_candidate_weak = *it_PropertiesForConstraint_inverse; if( self_candidate_weak.expired() ) { ++it_PropertiesForConstraint_inverse; continue; } shared_ptr<IfcResourceConstraintRelationship> self_candidate( *it_PropertiesForConstraint_inverse ); if( self_candidate.get() == this ) { it_PropertiesForConstraint_inverse= PropertiesForConstraint_inverse.erase( it_PropertiesForConstraint_inverse ); } else { ++it_PropertiesForConstraint_inverse; } } } }
void IfcRelReferencedInSpatialStructure::unlinkFromInverseCounterparts() { IfcRelConnects::unlinkFromInverseCounterparts(); for( size_t i=0; i<m_RelatedElements.size(); ++i ) { shared_ptr<IfcElement> RelatedElements_IfcElement = dynamic_pointer_cast<IfcElement>( m_RelatedElements[i] ); if( RelatedElements_IfcElement ) { std::vector<weak_ptr<IfcRelReferencedInSpatialStructure> >& ReferencedInStructures_inverse = RelatedElements_IfcElement->m_ReferencedInStructures_inverse; for( auto it_ReferencedInStructures_inverse = ReferencedInStructures_inverse.begin(); it_ReferencedInStructures_inverse != ReferencedInStructures_inverse.end(); ) { weak_ptr<IfcRelReferencedInSpatialStructure> self_candidate_weak = *it_ReferencedInStructures_inverse; if( self_candidate_weak.expired() ) { ++it_ReferencedInStructures_inverse; continue; } shared_ptr<IfcRelReferencedInSpatialStructure> self_candidate( *it_ReferencedInStructures_inverse ); if( self_candidate.get() == this ) { it_ReferencedInStructures_inverse= ReferencedInStructures_inverse.erase( it_ReferencedInStructures_inverse ); } else { ++it_ReferencedInStructures_inverse; } } } } if( m_RelatingStructure ) { std::vector<weak_ptr<IfcRelReferencedInSpatialStructure> >& ReferencesElements_inverse = m_RelatingStructure->m_ReferencesElements_inverse; for( auto it_ReferencesElements_inverse = ReferencesElements_inverse.begin(); it_ReferencesElements_inverse != ReferencesElements_inverse.end(); ) { weak_ptr<IfcRelReferencedInSpatialStructure> self_candidate_weak = *it_ReferencesElements_inverse; if( self_candidate_weak.expired() ) { ++it_ReferencesElements_inverse; continue; } shared_ptr<IfcRelReferencedInSpatialStructure> self_candidate( *it_ReferencesElements_inverse ); if( self_candidate.get() == this ) { it_ReferencesElements_inverse= ReferencesElements_inverse.erase( it_ReferencesElements_inverse ); } else { ++it_ReferencesElements_inverse; } } } }
void IfcRelDefinesByProperties::unlinkSelf() { IfcRelDefines::unlinkSelf(); for( int i=0; i<m_RelatedObjects.size(); ++i ) { shared_ptr<IfcContext> RelatedObjects_IfcContext = dynamic_pointer_cast<IfcContext>( m_RelatedObjects[i] ); if( RelatedObjects_IfcContext ) { std::vector<weak_ptr<IfcRelDefinesByProperties> >& IsDefinedBy_inverse = RelatedObjects_IfcContext->m_IsDefinedBy_inverse; std::vector<weak_ptr<IfcRelDefinesByProperties> >::iterator it_IsDefinedBy_inverse; for( it_IsDefinedBy_inverse = IsDefinedBy_inverse.begin(); it_IsDefinedBy_inverse != IsDefinedBy_inverse.end(); ++it_IsDefinedBy_inverse) { shared_ptr<IfcRelDefinesByProperties> self_candidate( *it_IsDefinedBy_inverse ); if( self_candidate->getId() == this->getId() ) { IsDefinedBy_inverse.erase( it_IsDefinedBy_inverse ); break; } } } shared_ptr<IfcObject> RelatedObjects_IfcObject = dynamic_pointer_cast<IfcObject>( m_RelatedObjects[i] ); if( RelatedObjects_IfcObject ) { std::vector<weak_ptr<IfcRelDefinesByProperties> >& IsDefinedBy_inverse = RelatedObjects_IfcObject->m_IsDefinedBy_inverse; std::vector<weak_ptr<IfcRelDefinesByProperties> >::iterator it_IsDefinedBy_inverse; for( it_IsDefinedBy_inverse = IsDefinedBy_inverse.begin(); it_IsDefinedBy_inverse != IsDefinedBy_inverse.end(); ++it_IsDefinedBy_inverse) { shared_ptr<IfcRelDefinesByProperties> self_candidate( *it_IsDefinedBy_inverse ); if( self_candidate->getId() == this->getId() ) { IsDefinedBy_inverse.erase( it_IsDefinedBy_inverse ); break; } } } } shared_ptr<IfcPropertySetDefinition> RelatingPropertyDefinition_IfcPropertySetDefinition = dynamic_pointer_cast<IfcPropertySetDefinition>( m_RelatingPropertyDefinition ); if( RelatingPropertyDefinition_IfcPropertySetDefinition ) { std::vector<weak_ptr<IfcRelDefinesByProperties> >& DefinesOccurrence_inverse = RelatingPropertyDefinition_IfcPropertySetDefinition->m_DefinesOccurrence_inverse; std::vector<weak_ptr<IfcRelDefinesByProperties> >::iterator it_DefinesOccurrence_inverse; for( it_DefinesOccurrence_inverse = DefinesOccurrence_inverse.begin(); it_DefinesOccurrence_inverse != DefinesOccurrence_inverse.end(); ++it_DefinesOccurrence_inverse) { shared_ptr<IfcRelDefinesByProperties> self_candidate( *it_DefinesOccurrence_inverse ); if( self_candidate->getId() == this->getId() ) { DefinesOccurrence_inverse.erase( it_DefinesOccurrence_inverse ); break; } } } }
void IfcRelCoversBldgElements::unlinkFromInverseCounterparts() { IfcRelConnects::unlinkFromInverseCounterparts(); for( size_t i=0; i<m_RelatedCoverings.size(); ++i ) { if( m_RelatedCoverings[i] ) { std::vector<weak_ptr<IfcRelCoversBldgElements> >& CoversElements_inverse = m_RelatedCoverings[i]->m_CoversElements_inverse; for( auto it_CoversElements_inverse = CoversElements_inverse.begin(); it_CoversElements_inverse != CoversElements_inverse.end(); ) { weak_ptr<IfcRelCoversBldgElements> self_candidate_weak = *it_CoversElements_inverse; if( self_candidate_weak.expired() ) { ++it_CoversElements_inverse; continue; } shared_ptr<IfcRelCoversBldgElements> self_candidate( *it_CoversElements_inverse ); if( self_candidate.get() == this ) { it_CoversElements_inverse= CoversElements_inverse.erase( it_CoversElements_inverse ); } else { ++it_CoversElements_inverse; } } } } if( m_RelatingBuildingElement ) { std::vector<weak_ptr<IfcRelCoversBldgElements> >& HasCoverings_inverse = m_RelatingBuildingElement->m_HasCoverings_inverse; for( auto it_HasCoverings_inverse = HasCoverings_inverse.begin(); it_HasCoverings_inverse != HasCoverings_inverse.end(); ) { weak_ptr<IfcRelCoversBldgElements> self_candidate_weak = *it_HasCoverings_inverse; if( self_candidate_weak.expired() ) { ++it_HasCoverings_inverse; continue; } shared_ptr<IfcRelCoversBldgElements> self_candidate( *it_HasCoverings_inverse ); if( self_candidate.get() == this ) { it_HasCoverings_inverse= HasCoverings_inverse.erase( it_HasCoverings_inverse ); } else { ++it_HasCoverings_inverse; } } } }
void IfcOrganizationRelationship::unlinkFromInverseCounterparts() { IfcResourceLevelRelationship::unlinkFromInverseCounterparts(); for( size_t i=0; i<m_RelatedOrganizations.size(); ++i ) { if( m_RelatedOrganizations[i] ) { std::vector<weak_ptr<IfcOrganizationRelationship> >& IsRelatedBy_inverse = m_RelatedOrganizations[i]->m_IsRelatedBy_inverse; for( auto it_IsRelatedBy_inverse = IsRelatedBy_inverse.begin(); it_IsRelatedBy_inverse != IsRelatedBy_inverse.end(); ) { weak_ptr<IfcOrganizationRelationship> self_candidate_weak = *it_IsRelatedBy_inverse; if( self_candidate_weak.expired() ) { ++it_IsRelatedBy_inverse; continue; } shared_ptr<IfcOrganizationRelationship> self_candidate( *it_IsRelatedBy_inverse ); if( self_candidate.get() == this ) { it_IsRelatedBy_inverse= IsRelatedBy_inverse.erase( it_IsRelatedBy_inverse ); } else { ++it_IsRelatedBy_inverse; } } } } if( m_RelatingOrganization ) { std::vector<weak_ptr<IfcOrganizationRelationship> >& Relates_inverse = m_RelatingOrganization->m_Relates_inverse; for( auto it_Relates_inverse = Relates_inverse.begin(); it_Relates_inverse != Relates_inverse.end(); ) { weak_ptr<IfcOrganizationRelationship> self_candidate_weak = *it_Relates_inverse; if( self_candidate_weak.expired() ) { ++it_Relates_inverse; continue; } shared_ptr<IfcOrganizationRelationship> self_candidate( *it_Relates_inverse ); if( self_candidate.get() == this ) { it_Relates_inverse= Relates_inverse.erase( it_Relates_inverse ); } else { ++it_Relates_inverse; } } } }
void IfcRelDeclares::unlinkSelf() { IfcRelationship::unlinkSelf(); for( int i=0; i<m_RelatedDefinitions.size(); ++i ) { shared_ptr<IfcObjectDefinition> RelatedDefinitions_IfcObjectDefinition = dynamic_pointer_cast<IfcObjectDefinition>( m_RelatedDefinitions[i] ); if( RelatedDefinitions_IfcObjectDefinition ) { std::vector<weak_ptr<IfcRelDeclares> >& HasContext_inverse = RelatedDefinitions_IfcObjectDefinition->m_HasContext_inverse; std::vector<weak_ptr<IfcRelDeclares> >::iterator it_HasContext_inverse; for( it_HasContext_inverse = HasContext_inverse.begin(); it_HasContext_inverse != HasContext_inverse.end(); ++it_HasContext_inverse) { shared_ptr<IfcRelDeclares> self_candidate( *it_HasContext_inverse ); if( self_candidate->getId() == this->getId() ) { HasContext_inverse.erase( it_HasContext_inverse ); break; } } } shared_ptr<IfcPropertyDefinition> RelatedDefinitions_IfcPropertyDefinition = dynamic_pointer_cast<IfcPropertyDefinition>( m_RelatedDefinitions[i] ); if( RelatedDefinitions_IfcPropertyDefinition ) { std::vector<weak_ptr<IfcRelDeclares> >& HasContext_inverse = RelatedDefinitions_IfcPropertyDefinition->m_HasContext_inverse; std::vector<weak_ptr<IfcRelDeclares> >::iterator it_HasContext_inverse; for( it_HasContext_inverse = HasContext_inverse.begin(); it_HasContext_inverse != HasContext_inverse.end(); ++it_HasContext_inverse) { shared_ptr<IfcRelDeclares> self_candidate( *it_HasContext_inverse ); if( self_candidate->getId() == this->getId() ) { HasContext_inverse.erase( it_HasContext_inverse ); break; } } } } if( m_RelatingContext ) { std::vector<weak_ptr<IfcRelDeclares> >& Declares_inverse = m_RelatingContext->m_Declares_inverse; std::vector<weak_ptr<IfcRelDeclares> >::iterator it_Declares_inverse; for( it_Declares_inverse = Declares_inverse.begin(); it_Declares_inverse != Declares_inverse.end(); ++it_Declares_inverse) { shared_ptr<IfcRelDeclares> self_candidate( *it_Declares_inverse ); if( self_candidate->getId() == this->getId() ) { Declares_inverse.erase( it_Declares_inverse ); break; } } } }
void IfcShapeAspect::unlinkSelf() { shared_ptr<IfcProductDefinitionShape> PartOfProductDefinitionShape_IfcProductDefinitionShape = dynamic_pointer_cast<IfcProductDefinitionShape>( m_PartOfProductDefinitionShape ); if( PartOfProductDefinitionShape_IfcProductDefinitionShape ) { std::vector<weak_ptr<IfcShapeAspect> >& HasShapeAspects_inverse = PartOfProductDefinitionShape_IfcProductDefinitionShape->m_HasShapeAspects_inverse; std::vector<weak_ptr<IfcShapeAspect> >::iterator it_HasShapeAspects_inverse; for( it_HasShapeAspects_inverse = HasShapeAspects_inverse.begin(); it_HasShapeAspects_inverse != HasShapeAspects_inverse.end(); ++it_HasShapeAspects_inverse) { shared_ptr<IfcShapeAspect> self_candidate( *it_HasShapeAspects_inverse ); if( self_candidate->getId() == this->getId() ) { HasShapeAspects_inverse.erase( it_HasShapeAspects_inverse ); break; } } } shared_ptr<IfcRepresentationMap> PartOfProductDefinitionShape_IfcRepresentationMap = dynamic_pointer_cast<IfcRepresentationMap>( m_PartOfProductDefinitionShape ); if( PartOfProductDefinitionShape_IfcRepresentationMap ) { std::vector<weak_ptr<IfcShapeAspect> >& HasShapeAspects_inverse = PartOfProductDefinitionShape_IfcRepresentationMap->m_HasShapeAspects_inverse; std::vector<weak_ptr<IfcShapeAspect> >::iterator it_HasShapeAspects_inverse; for( it_HasShapeAspects_inverse = HasShapeAspects_inverse.begin(); it_HasShapeAspects_inverse != HasShapeAspects_inverse.end(); ++it_HasShapeAspects_inverse) { shared_ptr<IfcShapeAspect> self_candidate( *it_HasShapeAspects_inverse ); if( self_candidate->getId() == this->getId() ) { HasShapeAspects_inverse.erase( it_HasShapeAspects_inverse ); break; } } } for( int i=0; i<m_ShapeRepresentations.size(); ++i ) { if( m_ShapeRepresentations[i] ) { std::vector<weak_ptr<IfcShapeAspect> >& OfShapeAspect_inverse = m_ShapeRepresentations[i]->m_OfShapeAspect_inverse; std::vector<weak_ptr<IfcShapeAspect> >::iterator it_OfShapeAspect_inverse; for( it_OfShapeAspect_inverse = OfShapeAspect_inverse.begin(); it_OfShapeAspect_inverse != OfShapeAspect_inverse.end(); ++it_OfShapeAspect_inverse) { shared_ptr<IfcShapeAspect> self_candidate( *it_OfShapeAspect_inverse ); if( self_candidate->getId() == this->getId() ) { OfShapeAspect_inverse.erase( it_OfShapeAspect_inverse ); break; } } } } }
void IfcRelAssignsToProcess::unlinkFromInverseCounterparts() { IfcRelAssigns::unlinkFromInverseCounterparts(); shared_ptr<IfcProcess> RelatingProcess_IfcProcess = dynamic_pointer_cast<IfcProcess>( m_RelatingProcess ); if( RelatingProcess_IfcProcess ) { std::vector<weak_ptr<IfcRelAssignsToProcess> >& OperatesOn_inverse = RelatingProcess_IfcProcess->m_OperatesOn_inverse; for( auto it_OperatesOn_inverse = OperatesOn_inverse.begin(); it_OperatesOn_inverse != OperatesOn_inverse.end(); ) { weak_ptr<IfcRelAssignsToProcess> self_candidate_weak = *it_OperatesOn_inverse; if( self_candidate_weak.expired() ) { ++it_OperatesOn_inverse; continue; } shared_ptr<IfcRelAssignsToProcess> self_candidate( *it_OperatesOn_inverse ); if( self_candidate.get() == this ) { it_OperatesOn_inverse= OperatesOn_inverse.erase( it_OperatesOn_inverse ); } else { ++it_OperatesOn_inverse; } } } shared_ptr<IfcTypeProcess> RelatingProcess_IfcTypeProcess = dynamic_pointer_cast<IfcTypeProcess>( m_RelatingProcess ); if( RelatingProcess_IfcTypeProcess ) { std::vector<weak_ptr<IfcRelAssignsToProcess> >& OperatesOn_inverse = RelatingProcess_IfcTypeProcess->m_OperatesOn_inverse; for( auto it_OperatesOn_inverse = OperatesOn_inverse.begin(); it_OperatesOn_inverse != OperatesOn_inverse.end(); ) { weak_ptr<IfcRelAssignsToProcess> self_candidate_weak = *it_OperatesOn_inverse; if( self_candidate_weak.expired() ) { ++it_OperatesOn_inverse; continue; } shared_ptr<IfcRelAssignsToProcess> self_candidate( *it_OperatesOn_inverse ); if( self_candidate.get() == this ) { it_OperatesOn_inverse= OperatesOn_inverse.erase( it_OperatesOn_inverse ); } else { ++it_OperatesOn_inverse; } } } }
void IfcRelConnectsStructuralActivity::unlinkFromInverseCounterparts() { IfcRelConnects::unlinkFromInverseCounterparts(); if( m_RelatedStructuralActivity ) { std::vector<weak_ptr<IfcRelConnectsStructuralActivity> >& AssignedToStructuralItem_inverse = m_RelatedStructuralActivity->m_AssignedToStructuralItem_inverse; for( auto it_AssignedToStructuralItem_inverse = AssignedToStructuralItem_inverse.begin(); it_AssignedToStructuralItem_inverse != AssignedToStructuralItem_inverse.end(); ) { weak_ptr<IfcRelConnectsStructuralActivity> self_candidate_weak = *it_AssignedToStructuralItem_inverse; if( self_candidate_weak.expired() ) { ++it_AssignedToStructuralItem_inverse; continue; } shared_ptr<IfcRelConnectsStructuralActivity> self_candidate( *it_AssignedToStructuralItem_inverse ); if( self_candidate.get() == this ) { it_AssignedToStructuralItem_inverse= AssignedToStructuralItem_inverse.erase( it_AssignedToStructuralItem_inverse ); } else { ++it_AssignedToStructuralItem_inverse; } } } shared_ptr<IfcStructuralItem> RelatingElement_IfcStructuralItem = dynamic_pointer_cast<IfcStructuralItem>( m_RelatingElement ); if( RelatingElement_IfcStructuralItem ) { std::vector<weak_ptr<IfcRelConnectsStructuralActivity> >& AssignedStructuralActivity_inverse = RelatingElement_IfcStructuralItem->m_AssignedStructuralActivity_inverse; for( auto it_AssignedStructuralActivity_inverse = AssignedStructuralActivity_inverse.begin(); it_AssignedStructuralActivity_inverse != AssignedStructuralActivity_inverse.end(); ) { weak_ptr<IfcRelConnectsStructuralActivity> self_candidate_weak = *it_AssignedStructuralActivity_inverse; if( self_candidate_weak.expired() ) { ++it_AssignedStructuralActivity_inverse; continue; } shared_ptr<IfcRelConnectsStructuralActivity> self_candidate( *it_AssignedStructuralActivity_inverse ); if( self_candidate.get() == this ) { it_AssignedStructuralActivity_inverse= AssignedStructuralActivity_inverse.erase( it_AssignedStructuralActivity_inverse ); } else { ++it_AssignedStructuralActivity_inverse; } } } }
void IfcRelConnectsPortToElement::unlinkFromInverseCounterparts() { IfcRelConnects::unlinkFromInverseCounterparts(); if( m_RelatedElement ) { std::vector<weak_ptr<IfcRelConnectsPortToElement> >& HasPorts_inverse = m_RelatedElement->m_HasPorts_inverse; for( auto it_HasPorts_inverse = HasPorts_inverse.begin(); it_HasPorts_inverse != HasPorts_inverse.end(); ) { weak_ptr<IfcRelConnectsPortToElement> self_candidate_weak = *it_HasPorts_inverse; if( self_candidate_weak.expired() ) { ++it_HasPorts_inverse; continue; } shared_ptr<IfcRelConnectsPortToElement> self_candidate( *it_HasPorts_inverse ); if( self_candidate.get() == this ) { it_HasPorts_inverse= HasPorts_inverse.erase( it_HasPorts_inverse ); } else { ++it_HasPorts_inverse; } } } if( m_RelatingPort ) { std::vector<weak_ptr<IfcRelConnectsPortToElement> >& ContainedIn_inverse = m_RelatingPort->m_ContainedIn_inverse; for( auto it_ContainedIn_inverse = ContainedIn_inverse.begin(); it_ContainedIn_inverse != ContainedIn_inverse.end(); ) { weak_ptr<IfcRelConnectsPortToElement> self_candidate_weak = *it_ContainedIn_inverse; if( self_candidate_weak.expired() ) { ++it_ContainedIn_inverse; continue; } shared_ptr<IfcRelConnectsPortToElement> self_candidate( *it_ContainedIn_inverse ); if( self_candidate.get() == this ) { it_ContainedIn_inverse= ContainedIn_inverse.erase( it_ContainedIn_inverse ); } else { ++it_ContainedIn_inverse; } } } }