/** * Set the list of roles * @param Collection $roles */ public function setRoles(Collection $roles) { $this->roles->clear(); foreach ($roles as $role) { $this->roles[] = $role; } }
/** * setGroups * * Set the users groups. * * @param UserGroup[]|\Traversable $groups The collection of user groups to set. * * @return $this */ public function setGroups($groups) { $this->groups->clear(); foreach ($groups as $group) { $this->addGroup($group); } return $this; }
/** * Set tags * * @param Collection $tags Tags * * @return Product self Object */ public function setTags(Collection $tags) { $this->tags->clear(); if (!$tags->isEmpty()) { foreach ($tags as $tag) { $this->addTag($tag); } } return $this; }
/** * setUsers * * Replace all current users with the provided collection. * * @param UserInterface[]|Collection $users The new users collection to set. * * @return $this * @throws Exception\InvalidArgumentException If the collection is not an array or \Traversable instance. */ public function setUsers($users) { if (!is_array($users) && !$users instanceof \Traversable) { throw new Exception\InvalidArgumentException(sprintf('The \'users\' argument must be an \'array\' or object of type \'%s\'; \'%s\' given in \'%s\'', \Traversable::class, is_object($users) ? get_class($users) : gettype($users), __METHOD__)); } $this->users->clear(); foreach ($users as $user) { $this->addUser($user); } return $this; }
/** * Map a data to a collection of model objects. * * @param array $data An array of data. * @param callable $callable The callable you want to call for each row of data. * @return Collection A collection of objects. */ protected function mapToObjects(array $data, callable $callable = null) { $this->collection->clear(); if (count($data) > 0) { foreach ($data as $row) { if (is_callable($callable)) { $this->collection->add(call_user_func($callable, $row)); } else { $this->collection->add($this->instantiateObject($row)); } } } return clone $this->collection; }
/** * @param TranslationInterface[]|Collection $translations */ public function setTranslations($translations) { $this->translations->clear(); foreach ($translations as $translation) { $this->addTranslation($translation); } }
/** * {@inheritdoc} */ public function clear() { if ($this->initialized && $this->isEmpty()) { return; } if ($this->isOrphanRemovalEnabled()) { $this->initialize(); foreach ($this->coll as $element) { $this->uow->scheduleOrphanRemoval($element); } } $this->mongoData = array(); $this->coll->clear(); // Nothing to do for inverse-side collections if (!$this->mapping['isOwningSide']) { return; } // Nothing to do if the collection was initialized but contained no data if ($this->initialized && empty($this->snapshot)) { return; } $this->changed(); $this->uow->scheduleCollectionDeletion($this); $this->takeSnapshot(); }
public function testClear() { $this->_coll[] = 'one'; $this->_coll[] = 'two'; $this->_coll->clear(); $this->assertEquals($this->_coll->isEmpty(), true); }
/** * {@inheritdoc} */ public function setVariants(Collection $variants) { $this->variants->clear(); foreach ($variants as $variant) { $this->addVariant($variant); } }
/** * Sets this variant option values. * * @param Collection $options * * @return $this Self object */ public function setOptions(Collection $options) { /* * We want to be able to assign an empty * ArrayCollection to variant options * * When the collection is not empty, each * option in the collection will be added * separately since it needs to update the * parent product attribute list */ if ($options->isEmpty()) { $this->options = $options; } else { $this->options->clear(); } /** * @var ValueInterface $option */ foreach ($options as $option) { /* * We need to update the parent product attribute collection */ $this->addOption($option); } return $this; }
/** * Set addresses. * * This method could not be named setAddresses because of bug CRM-253. * * @param Collection|AbstractAddress[] $addresses * @return BasePerson */ public function resetAddresses($addresses) { $this->addresses->clear(); foreach ($addresses as $address) { $this->addAddress($address); } return $this; }
/** * Set children locales * * @param Collection|Locale[] $locales * * @return Locale */ public function resetLocales($locales) { $this->childLocales->clear(); foreach ($locales as $locale) { $this->addChildLocale($locale); } return $this; }
/** * {@inheritdoc} */ public function clear() { if ($this->initialized && $this->isEmpty()) { return; } $this->coll->clear(); $this->changed(); $this->takeSnapshot(); }
/** * {@inheritdoc} */ public function clear() { $this->_initialize(); $result = $this->_coll->clear(); if ($this->_mapping->isOwningSide) { $this->_changed(); $this->_dm->getUnitOfWork()->scheduleCollectionDeletion($this); } return $result; }
/** * {@inheritDoc} */ public function partition(Closure $p) { $array = $this->toArray(); $this->collection->clear(); foreach ($array as $key => $element) { $this->collection->set($key, $element); } $partitions = $this->collection->partition($p); return [new static($partitions[0]), new static($partitions[1])]; }
/** * @param Collection $groups */ public function setGroups($groups) { foreach ($this->groups as $group) { $this->removeGroup($group); } $this->groups->clear(); foreach ($groups as $group) { $this->addGroup($group); } }
/** * {@inheritdoc} */ public function clear() { if ($this->initialized && $this->isEmpty()) { return; } if ($this->isOrphanRemovalEnabled()) { foreach ($this->coll as $element) { $this->uow->scheduleOrphanRemoval($element); } } $this->mongoData = array(); $this->coll->clear(); if ($this->mapping['isOwningSide']) { $this->changed(); $this->uow->scheduleCollectionDeletion($this); $this->takeSnapshot(); } }
/** * don't clone id to create a new entities. */ public function __clone() { if ($this->id) { $this->id = null; /** @var FileVersionMeta[] $newMetaList */ $newMetaList = []; $defaultMetaLocale = $this->getDefaultMeta()->getLocale(); /** @var FileVersionContentLanguage[] $newContentLanguageList */ $newContentLanguageList = []; /** @var FileVersionPublishLanguage[] $newPublishLanguageList */ $newPublishLanguageList = []; /** @var FileVersionMeta $meta */ foreach ($this->meta as $meta) { $newMetaList[] = clone $meta; } $this->meta->clear(); foreach ($newMetaList as $newMeta) { $newMeta->setFileVersion($this); $this->addMeta($newMeta); if ($newMeta->getLocale() === $defaultMetaLocale) { $this->setDefaultMeta($newMeta); } } /** @var FileVersionContentLanguage $contentLanguage */ foreach ($this->contentLanguages as $contentLanguage) { $newContentLanguageList[] = clone $contentLanguage; } $this->contentLanguages->clear(); foreach ($newContentLanguageList as $newContentLanguage) { $newContentLanguage->setFileVersion($this); $this->addContentLanguage($newContentLanguage); } /** @var FileVersionPublishLanguage $publishLanguage */ foreach ($this->publishLanguages as $publishLanguage) { $newPublishLanguageList[] = clone $publishLanguage; } $this->publishLanguages->clear(); foreach ($newPublishLanguageList as $newPublishLanguage) { $newPublishLanguage->setFileVersion($this); $this->addPublishLanguage($newPublishLanguage); } } }
/** * {@inheritdoc} */ public function clear() { if ($this->initialized && $this->isEmpty()) { return; } if ($this->association['type'] == ClassMetadata::ONE_TO_MANY && $this->association['orphanRemoval']) { // we need to initialize here, as orphan removal acts like implicit cascadeRemove, // hence for event listeners we need the objects in memory. $this->initialize(); foreach ($this->coll as $element) { $this->em->getUnitOfWork()->scheduleOrphanRemoval($element); } } $this->coll->clear(); $this->initialized = true; // direct call, {@link initialize()} is too expensive if ($this->association['isOwningSide']) { $this->changed(); $this->em->getUnitOfWork()->scheduleCollectionDeletion($this); $this->takeSnapshot(); } }
public function removeAllEmployment() { if (isset($this->employment)) { $this->employment->clear(); } }
/** * {@inheritDoc} */ public function clear() { $this->initialize(); $this->collection->clear(); }
/** * Pass an array or Collection of Role objects and re-set roles collection with new Roles. * Type hinted array due to interface. * * @param array|Collection $roles Array of Role objects * * @return User * @throws \InvalidArgumentException */ public function setRoles($roles) { if (!$roles instanceof Collection && !is_array($roles)) { throw new \InvalidArgumentException('$roles must be an instance of Doctrine\\Common\\Collections\\Collection or an array'); } $this->roles->clear(); foreach ($roles as $role) { $this->addRole($role); } return $this; }
/** * Helper function which checks the option configuration for the passed collection. * If the data property contains the "__options_$optionName" value and this value contains * the "replace" parameter the collection will be cleared. * * @param Collection $collection * @param $data * @param $optionName * @param $defaultReplace * @return \Doctrine\Common\Collections\Collection */ protected function checkDataReplacement(Collection $collection, $data, $optionName, $defaultReplace) { $key = '__options_' . $optionName; if (isset($data[$key])) { if ($data[$key]['replace']) { $collection->clear(); } } elseif ($defaultReplace) { $collection->clear(); } return $collection; }
/** * {@inheritdoc} */ public function clear() { $this->tasks->clear(); }
/** * {@inheritdoc} */ public function clear() { if ($this->initialized && $this->isEmpty()) { return; } if ($this->association->isOneToMany() && $this->association->orphanRemoval) { foreach ($this->coll as $element) { $this->em->getUnitOfWork()->scheduleOrphanRemoval($element); } } $this->coll->clear(); if ($this->association->isOwningSide) { $this->changed(); $this->em->getUnitOfWork()->scheduleCollectionDeletion($this); $this->takeSnapshot(); } }
/** * {@inheritdoc} */ public function clearAdjustments() { $this->adjustments->clear(); $this->recalculateAdjustmentsTotal(); }
/** * {@inheritdoc} */ public function removeShipments() { $this->shipments->clear(); }
/** * @param string $value * @param Collection $collection */ public function reverseTransform($value, $collection) { if (strlen(trim($value)) == 0) { // don't check for collection count, a straight clear doesnt initialize the collection $collection->clear(); return $collection; } $callback = $this->getOption('explode_callback'); $values = call_user_func($callback, $this->getOption('separator'), $value); if ($this->getOption('trim') === true) { $values = array_map('trim', $values); } /* @var $em Doctrine\ORM\EntityManager */ $em = $this->getOption('em'); $className = $this->getOption('class_name'); $reflField = $em->getClassMetadata($className)->getReflectionProperty($this->getOption('field_name')); // 1. removing elements that are not yet present anymore foreach ($collection as $object) { $uniqueIdent = $reflField->getValue($object); $key = array_search($uniqueIdent, $values); if ($key === false) { $collection->removeElement($object); } else { // found in the collection, no need to do anything with it so remove it unset($values[$key]); } } // 2. add elements that are known to the EntityManager but newly connected, query them from the repository if (count($values)) { $dql = sprintf('SELECT o FROM %s o WHERE o.%s IN (', $className, $this->getOption('field_name')); $query = $em->createQuery(); $needles = array(); $i = 0; foreach ($values as $val) { $query->setParameter(++$i, $val); $needles[] = '?' . $i; } $dql .= implode(',', $needles) . ')'; $query->setDql($dql); $newElements = $query->getResult(); foreach ($newElements as $object) { $collection->add($object); $uniqueIdent = $reflField->getValue($object); $key = array_search($uniqueIdent, $values); unset($values[$key]); } } // 3. new elements that are not in the repository have to be created and persisted then attached: if (count($values)) { $callback = $this->getOption('create_instance_callback'); if (!$callback || !is_callable($callback)) { throw new TransformationFailedException('Cannot transform list of identifiers, because a new element was detected and it is unknown how to create an instance of this element.'); } foreach ($values as $newValue) { $newInstance = call_user_func($callback, $newValue); if (!$newInstance instanceof $className) { throw new TransformationFailedException(sprintf('Error while trying to create a new instance for the identifier "%s". No new instance was created.', $newValue)); } $collection->add($newInstance); $em->persist($newInstance); } } return $collection; }
/** * Removes all the items from the container * * @return $this */ public function clearItems() { $this->items->clear(); return $this; }
/** * {@inheritdoc} */ public function clearAdjustments() { return $this->adjustments->clear(); }