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;
				}
			}
		}
	}
}