PHP ArrayCollection::forAll方法代码示例

 /**
  * {@inheritdoc}
  */
 public function getNotificationEmails()
 {
     $emails = [];
     $this->businessUnits->forAll(function (BusinessUnit $bu) use(&$emails) {
         $emails = array_merge($emails, $bu->getNotificationEmails());
     });
     return new ArrayCollection($emails);
 }

 public function clearCollections()
 {
     $this->hookedObjectCollections->forAll(function ($key, HookedObjectCollectionEntity $hookedObjectCollectionEntity) {
         $hookedObjectCollectionEntity->getCollection()->getHookedObjectCollections()->removeElement($hookedObjectCollectionEntity);
         $hookedObjectCollectionEntity->setCollection(null)->setHookedObject(null);
     });
     $this->hookedObjectCollections->clear();
 }

 /**
  * @param Itinerary $other
  * @return bool
  */
 public function sameValueAs(Itinerary $other) : bool
 {
     //We use doctrine's ArrayCollection only to ease comparison
     //If Legs would be stored in an ArrayCollection hole the time
     //Itinerary itself would not be immutable,
     //cause a client could call $itinerary->legs()->add($anotherLeg);
     //Keeping ValueObjects immutable is a rule of thumb
     $myLegs = new ArrayCollection($this->legs());
     $otherLegs = new ArrayCollection($other->legs());
     if ($myLegs->count() !== $otherLegs->count()) {
         return false;
     }
     return $myLegs->forAll(function ($index, Leg $leg) use($otherLegs) {
         return $otherLegs->exists(function ($otherIndex, Leg $otherLeg) use($leg) {
             return $otherLeg->sameValueAs($leg);
         });
     });
 }

 /**
  * @param mixed $valueOrObject
  * @param string $target
  * @return array
  */
 protected function toMany($valueOrObject, $target, Collection $collection = null, $depth = 2)
 {
     if (!is_array($valueOrObject) && !$valueOrObject instanceof Traversable) {
         $valueOrObject = (array) $valueOrObject;
     }
     if (!$collection instanceof Collection) {
         $collection = new ArrayCollection();
     }
     $keepers = array();
     foreach ($valueOrObject as $value) {
         if (method_exists($value, 'toArray')) {
             $value = $value->toArray($depth);
         } else {
             if (!is_array($value) && !$value instanceof Traversable) {
                 $value = (array) $value;
             }
         }
         if (isset($value['id']) && strlen($value['id']) && ($found = $this->find($target, $value['id']))) {
             $keepers[] = $found->id;
             $this->hydrate($value, $found);
         } else {
             $obj = new $target();
             $obj->fromArray($value);
             $obj->id = null;
             if ($collection instanceof PersistentCollection) {
                 if ($owner = $collection->getOwner()) {
                     $mapping = $collection->getMapping();
                     $mappedBy = $mapping['mappedBy'];
                     $obj->{$mappedBy} = $owner;
                 }
             }
             $collection->add($obj);
         }
     }
     $collection->forAll(function ($key, $element) use($collection, $keepers) {
         if (strlen($element->id) && !in_array($element->id, $keepers)) {
             $collection->remove($key);
         }
     });
     return $collection;
 }

 /**
  * Constructor
  *
  * @param string $text
  * @param WordFactory $wordFactory
  */
 public function __construct($text, WordFactory $wordFactory)
 {
     $this->text = $text;
     $this->words = new ArrayCollection(explode(' ', $text));
     $this->words->forAll(function ($index, $word) use($wordFactory) {
         $this->words->set($index, $wordFactory->make($word));
         return true;
     });
 }

 public function forAll(Closure $p)
 {
     if (null === $this->entries) {
         $this->__load___();
     }
     return $this->entries->forAll($p);
 }

 public function testReferenceMany()
 {
     $colPush = new ArrayCollection(array(new GH453ReferencedDocument(), new GH453ReferencedDocument(), new GH453ReferencedDocument()));
     $colSet = $colPush->map(function ($v) {
         return clone $v;
     });
     $colSetArray = $colPush->map(function ($v) {
         return clone $v;
     });
     $colAddToSet = $colPush->map(function ($v) {
         return clone $v;
     });
     $dm = $this->dm;
     $colPush->forAll(function ($k, $v) use($dm) {
         $dm->persist($v);
         return true;
     });
     $colSet->forAll(function ($k, $v) use($dm) {
         $dm->persist($v);
         return true;
     });
     $colSetArray->forAll(function ($k, $v) use($dm) {
         $dm->persist($v);
         return true;
     });
     $colAddToSet->forAll(function ($k, $v) use($dm) {
         $dm->persist($v);
         return true;
     });
     $doc = new GH453Document();
     $doc->referenceManyPush = $colPush;
     $doc->referenceManySet = $colSet;
     $doc->referenceManySetArray = $colSetArray;
     $doc->referenceManyAddToSet = $colAddToSet;
     $this->dm->persist($doc);
     $this->dm->flush();
     $this->dm->clear();
     // No need to assert the value of the referenced document structure
     $this->assertBsonArray($doc->id, 'referenceManyPush');
     $this->assertBsonArray($doc->id, 'referenceManySet');
     $this->assertBsonArray($doc->id, 'referenceManySetArray');
     $this->assertBsonArray($doc->id, 'referenceManyAddToSet');
     // Check that the value is changed properly
     unset($colPush[1], $colSet[1], $colSetArray[1], $colAddToSet[1]);
     $doc->referenceManyPush = $colPush;
     $doc->referenceManySet = $colSet;
     $doc->referenceManySetArray = $colSetArray;
     $doc->referenceManyAddToSet = $colAddToSet;
     /* Merging must be done after re-assigning the collections, as the
      * referenced documents must be re-persisted through the merge cascade.
      */
     $doc = $this->dm->merge($doc);
     $this->dm->flush();
     $this->dm->clear();
     $this->assertBsonArray($doc->id, 'referenceManyPush');
     $this->assertBsonObject($doc->id, 'referenceManySet');
     $this->assertBsonArray($doc->id, 'referenceManySetArray');
     $this->assertBsonArray($doc->id, 'referenceManyAddToSet');
 }

 /** {@inheritDoc} */
 public function forAll(Closure $p)
 {
     $this->initialize();
     return $this->collection->forAll($p);
 }

 /**
  * Tests whether the given predicate p holds for all elements of this collection.
  *
  * @param Closure $p The predicate.
  *
  * @return boolean TRUE, if the predicate yields TRUE for all elements, FALSE otherwise.
  */
 public function forAll(Closure $p)
 {
     return $this->collection->forAll($p);
 }

 /**
  * Create a new order
  *
  * @param Application $app
  * @param Request     $request
  *
  * @return RedirectResponse|JsonResponse
  */
 public function createOrder(Application $app, Request $request)
 {
     $success = false;
     $collectionHasOrderAdmins = new ArrayCollection();
     $toRemove = [];
     $records = RecordsRequest::fromRequest($app, $request, true, ['cancmd']);
     $hasOneAdmin = [];
     if (!$records->isEmpty()) {
         $order = new OrderEntity();
         $order->setUser($app['authentication']->getUser());
         $order->setDeadline(null !== ($deadLine = $request->request->get('deadline')) ? new \DateTime($deadLine) : $deadLine);
         $order->setOrderUsage($request->request->get('use', ''));
         foreach ($records as $key => $record) {
             if ($collectionHasOrderAdmins->containsKey($record->get_base_id())) {
                 if (!$collectionHasOrderAdmins->get($record->get_base_id())) {
                     $records->remove($key);
                 }
             }
             if (!isset($hasOneAdmin[$record->get_base_id()])) {
                 $query = new \User_Query($app);
                 $hasOneAdmin[$record->get_base_id()] = (bool) count($query->on_base_ids([$record->get_base_id()])->who_have_right(['order_master'])->execute()->get_results());
             }
             $collectionHasOrderAdmins->set($record->get_base_id(), $hasOneAdmin[$record->get_base_id()]);
             if (!$hasOneAdmin[$record->get_base_id()]) {
                 $toRemove[] = $key;
             } else {
                 $orderElement = new OrderElement();
                 $order->addElement($orderElement);
                 $orderElement->setOrder($order);
                 $orderElement->setBaseId($record->get_base_id());
                 $orderElement->setRecordId($record->get_record_id());
                 $app['EM']->persist($orderElement);
             }
         }
         foreach ($toRemove as $key) {
             if ($records->containsKey($key)) {
                 $records->remove($key);
             }
         }
         $noAdmins = $collectionHasOrderAdmins->forAll(function ($key, $hasAdmin) {
             return false === $hasAdmin;
         });
         if ($noAdmins) {
             $msg = $app->trans('There is no one to validate orders, please contact an administrator');
         }
         $order->setTodo($order->getElements()->count());
         try {
             $app['events-manager']->trigger('__NEW_ORDER__', ['order_id' => $order->getId(), 'usr_id' => $order->getUser()->getId()]);
             $success = true;
             $app['EM']->persist($order);
             $app['EM']->flush();
         } catch (\Exception $e) {
         }
         if ($success) {
             $msg = $app->trans('The records have been properly ordered');
         } else {
             $msg = $app->trans('An error occured');
         }
     } else {
         $msg = $app->trans('There is no record eligible for an order');
     }
     if ('json' === $app['request']->getRequestFormat()) {
         return $app->json(['success' => $success, 'msg' => $msg]);
     }
     return $app->redirectPath('prod_orders', ['success' => (int) $success, 'action' => 'send']);
 }

 function forAll(\Closure $p)
 {
     return $this->fields->forAll($p);
 }

 /**
  * @inheritdoc
  * @todo change since and flags to array of options after implementing another VCS type.
  */
 public function commits($since = '', $flags = 0)
 {
     // if (!$this->isDeployed()) {
     //    // @todo throw exception or clone
     // }
     $commandParts = [];
     $commandParts['executable'] = (string) $this->gitExecutablePath;
     $commandParts['remotePath'] = '-C "' . $this->repoPath . '"';
     $commandParts['action'] = 'log --date=iso --numstat';
     $commandParts['option-no-merges'] = $this->hasFlag(VCS_FLAG_NO_MERGES, $flags) ? '--no-merges' : '';
     $commandParts['option-no-walk'] = $this->hasFlag(VCS_FLAG_NO_WALK, $flags) ? '--no-walk' : '';
     $commandParts['option-tags'] = $this->hasFlag(VCS_FLAG_TAGS, $flags) ? '--tags' : '';
     $commandParts['format'] = '--pretty=format:"{\\"commit\\":\\"%H\\",\\"committer_name\\":\\"%cN\\",\\"committer_email\\":\\"%cE\\",\\"committer_date\\":\\"%ci\\",\\"subject\\":\\"%f\\"}"';
     $commandParts['since'] = strlen($since) > 0 ? '--since="' . $since . '"' : '';
     $commandString = implode(' ', array_filter($commandParts));
     $extractListing = new ArrayCollection($this->launcher->run($commandString));
     $responseListing = new ArrayCollection();
     $state = [];
     $extractListing->forAll(function ($index, $item) use($responseListing, &$state) {
         switch (true) {
             case trim($item) === '':
                 break;
             case substr($item, 0, 1) === '{':
                 // adding an item that didn't have changed files (successive log entries)
                 if (count($state) > 0) {
                     $commit = Commit::build($state);
                     $responseListing->set($commit->sha, $commit);
                 }
                 $state = json_decode($item, true);
                 $state['changes'] = [];
                 break;
             default:
                 $parts = explode("\t", $item);
                 if (count($parts) === 3 && $responseListing->count() > 0) {
                     $responseListing->last()->putChangedFile($parts[2], $parts[0], $parts[1]);
                 }
                 break;
         }
         return true;
     });
     return $responseListing;
 }