PHP ArrayCollection::indexOf方法代码示例

 public function indexOf($element)
 {
     if (null === $this->entries) {
         $this->__load___();
     }
     return $this->entries->indexOf($element);
 }

 /**
  * @param AbstractAddress $address
  * @return string
  */
 public function getIdentifier(AbstractAddress $address)
 {
     $className = ClassUtils::getClass($address);
     if (!$this->map->contains($className)) {
         throw new \InvalidArgumentException(sprintf('Entity with "%s" not registered', $className));
     }
     return sprintf('%s%s%s', $this->map->indexOf($className), self::DELIMITER, $address->getId());
 }

 public function removeReport(ReportModule $reportModule)
 {
     $index = $this->modules->indexOf($reportModule);
     if ($index !== null) {
         $this->modules->remove($index);
     }
     return $this;
 }

 public function indexOf($element)
 {
     $index = parent::indexOf($element);
     if (is_numeric($index)) {
         $index += 1;
     }
     return $index;
 }

 public function removeCourse(CourseModule $courseModule)
 {
     $index = $this->modules->indexOf($courseModule);
     if ($index !== null) {
         $this->modules->remove($index);
     }
     return $this;
 }

 /**
  * Tests IdentityWrapper->indexOf()
  */
 public function testIndexOf()
 {
     foreach ($this->entries as $key => $entry) {
         $this->assertSame($key, $this->identityWrapper->indexOf($entry));
         $this->assertNotSame($key, $this->wrappedCollection->indexOf($entry));
     }
     $this->assertFalse($this->identityWrapper->indexOf('non-existent'));
 }

 /**
  * Filtering collection
  *
  * @param ArrayCollection|CrudEntityInterface[] $collection Collection
  * @param bool                                  $replace    replace
  *
  * @return CrudUnitOfWork
  */
 public function filterCollection(ArrayCollection $collection, $replace = true)
 {
     $unitOfWork = new CrudUnitOfWork();
     foreach ($collection as $entity) {
         if ($entity->getId()) {
             $crudEntity = $this->find(get_class($entity), $entity->getId());
         } else {
             $this->crudTransformer->initializeClassMetadata(get_class($entity));
             $conditions = $this->crudTransformer->getUniqueSearchConditions($entity);
             $crudEntity = $this->entityManager->getRepository(get_class($entity))->findOneBy($conditions);
         }
         if ($crudEntity instanceof CrudEntityInterface) {
             if ($replace) {
                 $key = $collection->indexOf($entity);
                 $collection->remove($key);
                 $collection->set($key, $crudEntity);
             }
             $unitOfWork->update($crudEntity);
         } else {
             $unitOfWork->insert($entity);
         }
     }
     return $unitOfWork;
 }

 public function testIndexOf()
 {
     $elements = array(1, 'A' => 'a', 2, 'null' => null, 3, 'A2' => 'a', 'zero' => 0);
     $collection = new ArrayCollection($elements);
     $this->assertSame(array_search(2, $elements, true), $collection->indexOf(2), 'Index of 2');
     $this->assertSame(array_search(null, $elements, true), $collection->indexOf(null), 'Index of null');
     $this->assertSame(array_search('non-existent', $elements, true), $collection->indexOf('non-existent'), 'Index of non existent');
 }

 /**
  * Adds a subcontent to the collection.
  *
  * @param \BackBee\CoreDomain\ClassContent\AbstractClassContent $value
  *
  * @return string the unique identifier of the add subcontent
  */
 protected function _addSubcontent(AbstractClassContent $value)
 {
     if (!$this->_subcontent->indexOf($value)) {
         $this->_subcontent->add($value);
     }
     $this->subcontentmap[$value->getUid()] = $this->_subcontent->indexOf($value);
     return $value->getUid();
 }

 /**
  * Test if there is a previous oxfordable word
  * available to the conjunction
  *
  * @param Conjunction $word
  * @return bool
  */
 private function hasOxfordable(Conjunction $word)
 {
     $index = $this->words->indexOf($word);
     return $this->words->offsetExists($index - 1);
 }

 /** {@inheritDoc} */
 public function indexOf($element)
 {
     $this->initialize();
     return $this->collection->indexOf($element);
 }

 /**
  * Gets the index/key of a given element. The comparison of two elements is strict,
  * that means not only the value but also the type must match.
  * For objects this means reference equality.
  *
  * @param mixed $element The element to search for.
  *
  * @return int|string|bool The key/index of the element or FALSE if the element was not found.
  */
 public function indexOf($element)
 {
     return $this->collection->indexOf($element);
 }

 /**
  * @param Column $column
  *
  * @return bool|int|string
  */
 public function indexOf($column)
 {
     $this->columnTypeExpected($column);
     return parent::indexOf($column);
 }

 function indexOf($element)
 {
     return $this->fields->indexOf($element);
 }