PHP ObjectCollection::getCategoryId方法代码示例

 /**
  * Filter the query by a related \Thelia\Model\CategoryAssociatedContent object
  *
  * @param \Thelia\Model\CategoryAssociatedContent|ObjectCollection $categoryAssociatedContent  the related object to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return ChildCategoryQuery The current query, for fluid interface
  */
 public function filterByCategoryAssociatedContent($categoryAssociatedContent, $comparison = null)
 {
     if ($categoryAssociatedContent instanceof \Thelia\Model\CategoryAssociatedContent) {
         return $this->addUsingAlias(CategoryTableMap::ID, $categoryAssociatedContent->getCategoryId(), $comparison);
     } elseif ($categoryAssociatedContent instanceof ObjectCollection) {
         return $this->useCategoryAssociatedContentQuery()->filterByPrimaryKeys($categoryAssociatedContent->getPrimaryKeys())->endUse();
     } else {
         throw new PropelException('filterByCategoryAssociatedContent() only accepts arguments of type \\Thelia\\Model\\CategoryAssociatedContent or Collection');
     }
 }

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

 /**
  * Filter the query by a related \App\Propel\Product object
  *
  * @param \App\Propel\Product|ObjectCollection $product the related object to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return ChildCategoryQuery The current query, for fluid interface
  */
 public function filterByProduct($product, $comparison = null)
 {
     if ($product instanceof \App\Propel\Product) {
         return $this->addUsingAlias(CategoryTableMap::COL_CATEGORY_ID, $product->getCategoryId(), $comparison);
     } elseif ($product instanceof ObjectCollection) {
         return $this->useProductQuery()->filterByPrimaryKeys($product->getPrimaryKeys())->endUse();
     } else {
         throw new PropelException('filterByProduct() only accepts arguments of type \\App\\Propel\\Product or Collection');
     }
 }

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

 /**
  * Filter the query by a related \Categories object
  *
  * @param \Categories|ObjectCollection $categories The related object(s) to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @throws \Propel\Runtime\Exception\PropelException
  *
  * @return ChildItemsQuery The current query, for fluid interface
  */
 public function filterByCategories($categories, $comparison = null)
 {
     if ($categories instanceof \Categories) {
         return $this->addUsingAlias(ItemsTableMap::COL_CATEGORY_ID, $categories->getCategoryId(), $comparison);
     } elseif ($categories instanceof ObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(ItemsTableMap::COL_CATEGORY_ID, $categories->toKeyValue('PrimaryKey', 'CategoryId'), $comparison);
     } else {
         throw new PropelException('filterByCategories() only accepts arguments of type \\Categories 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 ChildCategoryQuery The current query, for fluid interface
  */
 public function filterByCategoryOption($categoryOption, $comparison = null)
 {
     if ($categoryOption instanceof \CategoryOption) {
         return $this->addUsingAlias(CategoryTableMap::COL_ID, $categoryOption->getCategoryId(), $comparison);
     } elseif ($categoryOption instanceof ObjectCollection) {
         return $this->useCategoryOptionQuery()->filterByPrimaryKeys($categoryOption->getPrimaryKeys())->endUse();
     } else {
         throw new PropelException('filterByCategoryOption() only accepts arguments of type \\CategoryOption or Collection');
     }
 }