Remove skillRelatedByCompositeId of this object
through the kk_trixionary_skill_part cross reference table.

@param ChildSkill $skillRelatedByCompositeId
@return ChildSkill The current object (for fluent API support)
347979
public function removeSkillRelatedByCompositeId(ChildSkill $skillRelatedByCompositeId)
    {
        if ($this->getSkillsRelatedByCompositeId()->contains($skillRelatedByCompositeId)) { $skillPart = new ChildSkillPart();

            $skillPart->setSkillRelatedByCompositeId($skillRelatedByCompositeId);
            if ($skillRelatedByCompositeId->isSkillRelatedByPartIdsLoaded()) {
                //remove the back reference if available
                $skillRelatedByCompositeId->getSkillRelatedByPartIds()->removeObject($this);
            }

            $skillPart->setSkillRelatedByPartId($this);
            $this->removePart(clone $skillPart);
            $skillPart->clear();

            $this->collSkillsRelatedByCompositeId->remove($this->collSkillsRelatedByCompositeId->search($skillRelatedByCompositeId));

            if (null === $this->skillsRelatedByCompositeIdScheduledForDeletion) {
                $this->skillsRelatedByCompositeIdScheduledForDeletion = clone $this->collSkillsRelatedByCompositeId;
                $this->skillsRelatedByCompositeIdScheduledForDeletion->clear();
            }

            $this->skillsRelatedByCompositeIdScheduledForDeletion->push($skillRelatedByCompositeId);
        }


        return $this;
    }
1041909
public function setSkills($skills)
    {
        foreach ($skills as $skill) {
            $skill->setWidget($this);
        }

        $this->skills = $skills;

        return $this;
    }
131582
public ProductPartitionNode removeChild(ProductDimension childDimension) {
    if (!children.containsKey(childDimension)) {
      throw new IllegalArgumentException(String.format(
          "Attempted to remove child %s but no such child exists", toString(childDimension)));
    }
    children.remove(childDimension);
    return this;
  }
752230
public function addSkill(ChildSkill $skill)
    {
        if ($this->collSkills === null) {
            $this->initSkills();
        }

        if (!$this->getSkills()->contains($skill)) {
            // only add it if the **same** object is not already associated
            $this->collSkills->push($skill);
            $this->doAddSkill($skill);
        }

        return $this;
    }
669228
public function getSkillRelatedByDependencyId(ConnectionInterface $con = null)
    {
        if ($this->aSkillRelatedByDependencyId === null && ($this->dependency_id !== null)) {
            $this->aSkillRelatedByDependencyId = ChildSkillQuery::create()->findPk($this->dependency_id, $con);
            /* The following can be used additionally to
                guarantee the related object contains a reference
                to this object.  This level of coupling may, however, be
                undesirable since it could result in an only partially populated collection
                in the referenced object.
                $this->aSkillRelatedByDependencyId->addChildren($this);
             */
        }

        return $this->aSkillRelatedByDependencyId;
    }
894927
protected function doSetMultipleOfId(Skill $model, $relatedId) {
		if ($model->getMultipleOfId() !== $relatedId) {
			$model->setMultipleOfId($relatedId);

			return true;
		}

		return false;
	}
130751
protected function doRemoveKstrukturs(Skill $model, $data) {
		$errors = [];
		foreach ($data as $entry) {
			if (!isset($entry['id'])) {
				$errors[] = 'Missing id for Kstruktur';
			} else {
				$related = KstrukturQuery::create()->findOneById($entry['id']);
				$model->removeKstruktur($related);
			}
		}

		if (count($errors) > 0) {
			return new ErrorsException($errors);
		}
	}
246101
public function removeChild(Node $child)
    {

        if (!isset($this->relations['children'])) {
            return $this;
        }

        $this->relations['children'] = array_filter($this->relations['children'], function($item){
            return ($item !== $child);
        });

        return $this;
    }
477326
public function removeChild(LeafRole $child)
    {
        $this->children->remove($child);
        $child->setParent(null);

        return $this;
    }
457703
public function setSkillRelatedByParentId(ChildSkill $v = null)
    {
        if ($v === null) {
            $this->setParentId(NULL);
        } else {
            $this->setParentId($v->getId());
        }

        $this->aSkillRelatedByParentId = $v;

        // Add binding for other direction of this n:n relationship.
        // If this object has already been added to the ChildSkill object, it will not be re-added.
        if ($v !== null) {
            $v->addParent($this);
        }


        return $this;
    }
404379
public static function clearRelatedInstancePool()
    {
        // Invalidate objects in related instance pools,
        // since one or more of them may be deleted by ON DELETE CASCADE/SETNULL rule.
        LineageTableMap::clearInstancePool();
        SkillDependencyTableMap::clearInstancePool();
        SkillPartTableMap::clearInstancePool();
        SkillGroupTableMap::clearInstancePool();
        PictureTableMap::clearInstancePool();
        VideoTableMap::clearInstancePool();
        SkillReferenceTableMap::clearInstancePool();
        StructureNodeTableMap::clearInstancePool();
        KstrukturTableMap::clearInstancePool();
        FunctionPhaseTableMap::clearInstancePool();
        SkillVersionTableMap::clearInstancePool();
    }
392453
protected function removeRelationFromRelationListField($contentId, array $row)
    {
        $document = new DOMDocument('1.0', 'utf-8');
        $document->loadXML($row['data_text']);

        $xpath = new DOMXPath($document);
        $xpathExpression = "//related-objects/relation-list/relation-item[@contentobject-id='{$contentId}']";

        $relationItems = $xpath->query($xpathExpression);
        foreach ($relationItems as $relationItem) {
            $relationItem->parentNode->removeChild($relationItem);
        }

        $query = $this->dbHandler->createUpdateQuery();
        $query
            ->update('ezcontentobject_attribute')
            ->set(
                'data_text',
                $query->bindValue($document->saveXML(), null, PDO::PARAM_STR)
            )
            ->where(
                $query->expr->lAnd(
                    $query->expr->eq(
                        $this->dbHandler->quoteColumn('id'),
                        $query->bindValue($row['id'], null, PDO::PARAM_INT)
                    ),
                    $query->expr->eq(
                        $this->dbHandler->quoteColumn('version'),
                        $query->bindValue($row['version'], null, PDO::PARAM_INT)
                    )
                )
            );

        $query->prepare()->execute();
    }
510349
public function removeChildrenEntity(Entity $childrenEntity)
    {
        foreach ($this->childrenEntities as $key => $childrenEntityElement) {
            if ($childrenEntityElement === $childrenEntity) {
                unset($this->childrenEntities[$key]);
                break;
            }
        }

        return $this;
    }
1093779
public function addSkillRelatedByParentId(ChildSkill $skillRelatedByParentId)
    {
        if ($this->collSkillsRelatedByParentId === null) {
            $this->initSkillsRelatedByParentId();
        }

        if (!$this->getSkillsRelatedByParentId()->contains($skillRelatedByParentId)) {
            // only add it if the **same** object is not already associated
            $this->collSkillsRelatedByParentId->push($skillRelatedByParentId);
            $this->doAddSkillRelatedByParentId($skillRelatedByParentId);
        }

        return $this;
    }
775993
protected function doUpdateComposites(Skill $model, $data) {
		// remove all relationships before
		SkillPartQuery::create()->filterBySkillRelatedByPartId($model)->delete();

		// add them
		$errors = [];
		foreach ($data as $entry) {
			if (!isset($entry['id'])) {
				$errors[] = 'Missing id for Skill';
			} else {
				$related = SkillQuery::create()->findOneById($entry['id']);
				$model->addSkillRelatedByCompositeId($related);
			}
		}

		if (count($errors) > 0) {
			throw new ErrorsException($errors);
		}
	}
1074160
public function removeRightRelation(\TechPromux\DynamicQueryBundle\Entity\MetadataRelation $rightRelation)
    {
        $this->rightRelations->removeElement($rightRelation);
    }
1085034
public function addSkill(ChildSkill $l)
    {
        if ($this->collSkills === null) {
            $this->initSkills();
            $this->collSkillsPartial = true;
        }

        if (!$this->collSkills->contains($l)) {
            $this->doAddSkill($l);
        }

        return $this;
    }