Remove skillRelatedByDependencyId of this object
through the kk_trixionary_skill_dependency cross reference table.

@param ChildSkill $skillRelatedByDependencyId
@return ChildSkill The current object (for fluent API support)
329657
public function removeSkillRelatedByDependencyId(ChildSkill $skillRelatedByDependencyId)
    {
        if ($this->getSkillsRelatedByDependencyId()->contains($skillRelatedByDependencyId)) { $skillDependency = new ChildSkillDependency();

            $skillDependency->setSkillRelatedByDependencyId($skillRelatedByDependencyId);
            if ($skillRelatedByDependencyId->isSkillRelatedByParentIdsLoaded()) {
                //remove the back reference if available
                $skillRelatedByDependencyId->getSkillRelatedByParentIds()->removeObject($this);
            }

            $skillDependency->setSkillRelatedByParentId($this);
            $this->removeParent(clone $skillDependency);
            $skillDependency->clear();

            $this->collSkillsRelatedByDependencyId->remove($this->collSkillsRelatedByDependencyId->search($skillRelatedByDependencyId));

            if (null === $this->skillsRelatedByDependencyIdScheduledForDeletion) {
                $this->skillsRelatedByDependencyIdScheduledForDeletion = clone $this->collSkillsRelatedByDependencyId;
                $this->skillsRelatedByDependencyIdScheduledForDeletion->clear();
            }

            $this->skillsRelatedByDependencyIdScheduledForDeletion->push($skillRelatedByDependencyId);
        }


        return $this;
    }
65278
public function removeSkillRelatedByPartId(ChildSkill $skillRelatedByPartId)
    {
        if ($this->getSkillsRelatedByPartId()->contains($skillRelatedByPartId)) { $skillPart = new ChildSkillPart();

            $skillPart->setSkillRelatedByPartId($skillRelatedByPartId);
            if ($skillRelatedByPartId->isSkillRelatedByCompositeIdsLoaded()) {
                //remove the back reference if available
                $skillRelatedByPartId->getSkillRelatedByCompositeIds()->removeObject($this);
            }

            $skillPart->setSkillRelatedByCompositeId($this);
            $this->removeComposite(clone $skillPart);
            $skillPart->clear();

            $this->collSkillsRelatedByPartId->remove($this->collSkillsRelatedByPartId->search($skillRelatedByPartId));

            if (null === $this->skillsRelatedByPartIdScheduledForDeletion) {
                $this->skillsRelatedByPartIdScheduledForDeletion = clone $this->collSkillsRelatedByPartId;
                $this->skillsRelatedByPartIdScheduledForDeletion->clear();
            }

            $this->skillsRelatedByPartIdScheduledForDeletion->push($skillRelatedByPartId);
        }


        return $this;
    }
695946
public function prune($skillPart = null)
    {
        if ($skillPart) {
            $this->addCond('pruneCond0', $this->getAliasedColName(SkillPartTableMap::COL_PART_ID), $skillPart->getPartId(), Criteria::NOT_EQUAL);
            $this->addCond('pruneCond1', $this->getAliasedColName(SkillPartTableMap::COL_COMPOSITE_ID), $skillPart->getCompositeId(), Criteria::NOT_EQUAL);
            $this->combine(array('pruneCond0', 'pruneCond1'), Criteria::LOGICAL_OR);
        }

        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;
    }
1348990
protected function doUpdateVariations(Skill $model, $data) {
		// remove all relationships before
		SkillQuery::create()->filterByVariationOf($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->addVariation($related);
			}
		}

		if (count($errors) > 0) {
			throw new ErrorsException($errors);
		}
	}
399840
public function removeRole(ChildRole $role)
    {
        if ($this->getRoles()->contains($role)) { $userRole = new ChildUserRole();

            $userRole->setRole($role);
            if ($role->isUsersLoaded()) {
                //remove the back reference if available
                $role->getUsers()->removeObject($this);
            }

            $userRole->setUser($this);
            $this->removeUserRole(clone $userRole);
            $userRole->clear();

            $this->collRoles->remove($this->collRoles->search($role));

            if (null === $this->rolesScheduledForDeletion) {
                $this->rolesScheduledForDeletion = clone $this->collRoles;
                $this->rolesScheduledForDeletion->clear();
            }

            $this->rolesScheduledForDeletion->push($role);
        }


        return $this;
    }
608538
protected function doRemoveLineages(Skill $model, $data) {
		$errors = [];
		foreach ($data as $entry) {
			if (!isset($entry['id'])) {
				$errors[] = 'Missing id for Lineage';
			} else {
				$related = LineageQuery::create()->findOneById($entry['id']);
				$model->removeLineage($related);
			}
		}

		if (count($errors) > 0) {
			return new ErrorsException($errors);
		}
	}
456085
public function getSkillRelatedByPartId(ConnectionInterface $con = null)
    {
        if ($this->aSkillRelatedByPartId === null && ($this->part_id !== null)) {
            $this->aSkillRelatedByPartId = ChildSkillQuery::create()->findPk($this->part_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->aSkillRelatedByPartId->addParts($this);
             */
        }

        return $this->aSkillRelatedByPartId;
    }
1232904
public function destroy($resourceId, $childResouceId)
    {
        $this->repository
        ->setResource($resourceId)
        ->setRelation($this->relation())
        ->delete($childResouceId);
        return $this->deletedResponse();
    }
766562
public function setSkillRelatedByCompositeId(ChildSkill $v = null)
    {
        if ($v === null) {
            $this->setCompositeId(NULL);
        } else {
            $this->setCompositeId($v->getId());
        }

        $this->aSkillRelatedByCompositeId = $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->addComposite($this);
        }


        return $this;
    }
403620
public function prune($skillVersion = null)
    {
        if ($skillVersion) {
            $this->addCond('pruneCond0', $this->getAliasedColName(SkillVersionTableMap::COL_ID), $skillVersion->getId(), Criteria::NOT_EQUAL);
            $this->addCond('pruneCond1', $this->getAliasedColName(SkillVersionTableMap::COL_VERSION), $skillVersion->getVersion(), Criteria::NOT_EQUAL);
            $this->combine(array('pruneCond0', 'pruneCond1'), Criteria::LOGICAL_OR);
        }

        return $this;
    }
704990
protected function doSetFeaturedPictureId(Skill $model, $relatedId) {
		if ($model->getPictureId() !== $relatedId) {
			$model->setPictureId($relatedId);

			return true;
		}

		return false;
	}
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();
    }
540497
public function setSkillRelatedByPartId(ChildSkill $v = null)
    {
        if ($v === null) {
            $this->setPartId(NULL);
        } else {
            $this->setPartId($v->getId());
        }

        $this->aSkillRelatedByPartId = $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->addPart($this);
        }


        return $this;
    }
904676
public function setSkillRelatedByDependencyId(ChildSkill $v = null)
    {
        if ($v === null) {
            $this->setDependencyId(NULL);
        } else {
            $this->setDependencyId($v->getId());
        }

        $this->aSkillRelatedByDependencyId = $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->addChild($this);
        }


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

			return true;
		}

		return false;
	}
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();
    }