PHP ObjectCollection::getParentId方法代码示例

 /**
  * Filter the query by a related \gossi\trixionary\model\SkillDependency object
  *
  * @param \gossi\trixionary\model\SkillDependency|ObjectCollection $skillDependency the related object to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return ChildSkillQuery The current query, for fluid interface
  */
 public function filterByParent($skillDependency, $comparison = null)
 {
     if ($skillDependency instanceof \gossi\trixionary\model\SkillDependency) {
         return $this->addUsingAlias(SkillTableMap::COL_ID, $skillDependency->getParentId(), $comparison);
     } elseif ($skillDependency instanceof ObjectCollection) {
         return $this->useParentQuery()->filterByPrimaryKeys($skillDependency->getPrimaryKeys())->endUse();
     } else {
         throw new PropelException('filterByParent() only accepts arguments of type \\gossi\\trixionary\\model\\SkillDependency or Collection');
     }
 }

 /**
  * Filter the query by a related \gossi\trixionary\model\StructureNodeParent object
  *
  * @param \gossi\trixionary\model\StructureNodeParent|ObjectCollection $structureNodeParent the related object to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return ChildStructureNodeQuery The current query, for fluid interface
  */
 public function filterByStructureNodeParentRelatedByParentId($structureNodeParent, $comparison = null)
 {
     if ($structureNodeParent instanceof \gossi\trixionary\model\StructureNodeParent) {
         return $this->addUsingAlias(StructureNodeTableMap::COL_ID, $structureNodeParent->getParentId(), $comparison);
     } elseif ($structureNodeParent instanceof ObjectCollection) {
         return $this->useStructureNodeParentRelatedByParentIdQuery()->filterByPrimaryKeys($structureNodeParent->getPrimaryKeys())->endUse();
     } else {
         throw new PropelException('filterByStructureNodeParentRelatedByParentId() only accepts arguments of type \\gossi\\trixionary\\model\\StructureNodeParent or Collection');
     }
 }

 /**
  * Filter the query by a related \Alchemy\Component\Cerberus\Model\Permission object
  *
  * @param \Alchemy\Component\Cerberus\Model\Permission|ObjectCollection $permission  the related object to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return ChildPermissionQuery The current query, for fluid interface
  */
 public function filterByPermissionRelatedById($permission, $comparison = null)
 {
     if ($permission instanceof \Alchemy\Component\Cerberus\Model\Permission) {
         return $this->addUsingAlias(PermissionTableMap::COL_ID, $permission->getParentId(), $comparison);
     } elseif ($permission instanceof ObjectCollection) {
         return $this->usePermissionRelatedByIdQuery()->filterByPrimaryKeys($permission->getPrimaryKeys())->endUse();
     } else {
         throw new PropelException('filterByPermissionRelatedById() only accepts arguments of type \\Alchemy\\Component\\Cerberus\\Model\\Permission or Collection');
     }
 }

 /**
  * Filter the query by a related \CategoryOption object
  *
  * @param \CategoryOption|ObjectCollection $categoryOption the related object to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return ChildCategoryOptionQuery The current query, for fluid interface
  */
 public function filterByCategoryOptionRelatedById($categoryOption, $comparison = null)
 {
     if ($categoryOption instanceof \CategoryOption) {
         return $this->addUsingAlias(CategoryOptionTableMap::COL_ID, $categoryOption->getParentId(), $comparison);
     } elseif ($categoryOption instanceof ObjectCollection) {
         return $this->useCategoryOptionRelatedByIdQuery()->filterByPrimaryKeys($categoryOption->getPrimaryKeys())->endUse();
     } else {
         throw new PropelException('filterByCategoryOptionRelatedById() only accepts arguments of type \\CategoryOption or Collection');
     }
 }

 /**
  * Filter the query by a related \keeko\core\model\Language object
  *
  * @param \keeko\core\model\Language|ObjectCollection $language the related object to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return ChildLanguageQuery The current query, for fluid interface
  */
 public function filterBySublanguage($language, $comparison = null)
 {
     if ($language instanceof \keeko\core\model\Language) {
         return $this->addUsingAlias(LanguageTableMap::COL_ID, $language->getParentId(), $comparison);
     } elseif ($language instanceof ObjectCollection) {
         return $this->useSublanguageQuery()->filterByPrimaryKeys($language->getPrimaryKeys())->endUse();
     } else {
         throw new PropelException('filterBySublanguage() only accepts arguments of type \\keeko\\core\\model\\Language or Collection');
     }
 }

 /**
  * Filter the query by a related \keeko\core\model\Localization object
  *
  * @param \keeko\core\model\Localization|ObjectCollection $localization the related object to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return ChildLocalizationQuery The current query, for fluid interface
  */
 public function filterByLocalizationRelatedById($localization, $comparison = null)
 {
     if ($localization instanceof \keeko\core\model\Localization) {
         return $this->addUsingAlias(LocalizationTableMap::COL_ID, $localization->getParentId(), $comparison);
     } elseif ($localization instanceof ObjectCollection) {
         return $this->useLocalizationRelatedByIdQuery()->filterByPrimaryKeys($localization->getPrimaryKeys())->endUse();
     } else {
         throw new PropelException('filterByLocalizationRelatedById() only accepts arguments of type \\keeko\\core\\model\\Localization or Collection');
     }
 }