/**
* This function performs a kind of "intersection union" operation, and is useful especially when dealing
* with dynamic forms. For instance, if a collection contains existing elements and a form remove one of those
* elements, this function will return a Collection that contains all the elements from $collection1, minus ones
* that are not present in $collection2. This is used internally in the DoctrineModule hydrator, so that the
* work is done for you automatically
*
* @param Collection $collection1
* @param Collection $collection2
* @return Collection
*/
public static function intersectUnion(Collection $collection1, Collection $collection2)
{
// Don't make the work both
if ($collection1 === $collection2) {
return $collection1;
}
$toRemove = array();
foreach ($collection1 as $key1 => $value1) {
$elementFound = false;
foreach ($collection2 as $key2 => $value2) {
if ($value1 === $value2) {
$elementFound = true;
unset($collection2[$key2]);
break;
}
}
if (!$elementFound) {
$toRemove[] = $key1;
}
}
// Remove elements that are in $collection1 but not in $collection2
foreach ($toRemove as $key) {
$collection1->remove($key);
}
// Add elements that are in $collection2 but not in $collection1
foreach ($collection2 as $value) {
$collection1->add($value);
}
return $collection1;
}
/**
* @param Empresa $empresa
*/
public function removeEmpresa($empresa)
{
if ($this->empresas->contains($empresa)) {
$empresa->setDirector(null);
$this->empresas->removeElement($empresa);
}
}
/**
* Remove item.
*
* @param \SWP\Component\Bridge\Model\Item $item
*/
public function removeItem(\SWP\Component\Bridge\Model\Item $item)
{
if ($this->items->contains($item)) {
$this->items->removeElement($item);
$item->setPackage(null);
}
}
/**
* Adds a post top the User's authored Posts.
*
* Post Author needs to be updated manually.
*
* @param Post $addPost
* @return User
*/
public function addPost(Post $addPost)
{
if (!$this->getAuthoredPosts()->contains($addPost)) {
$this->authoredPosts->add($addPost);
}
return $this;
}
/**
* Set the list of roles
* @param Collection $roles
*/
public function setRoles(Collection $roles)
{
$this->roles->clear();
foreach ($roles as $role) {
$this->roles[] = $role;
}
}
/**
* @param mixed $context
* @param Collection|null $errors
*/
protected function addError($context, Collection $errors = null)
{
if ($errors && $this->getMessage()) {
$messageParameters = $this->getMessageParameters($context);
$errors->add(array('message' => $this->getMessage(), 'parameters' => $messageParameters));
}
}
function let(LoaderInterface $loader, Collection $resourcesToThemes, ThemeInterface $theme)
{
$theme->getLogicalName()->willReturn("sylius/sample-theme");
$resourcesToThemes->get(realpath($this->getThemeTranslationResourcePath()))->willReturn($theme);
$resourcesToThemes->get(realpath($this->getVanillaTranslationResourcePath()))->willReturn(null);
$this->beConstructedWith($loader, $resourcesToThemes);
}
/**
* @param Role $parent
*/
public function addParent(Role $parent)
{
if ($this->parents->contains($parent)) {
throw new LogicException(sprintf("Parent role '%s' already assigned.", $parent->getId()));
}
$this->parents->add($parent);
}
/**
* {@inheritdoc}
*/
public function removeImage(TaxonImageInterface $image)
{
if ($this->hasImage($image)) {
$image->setTaxon(null);
$this->images->removeElement($image);
}
}
function it_applies_choice_filter_on_datasource_for_collection_value(FilterDatasourceAdapterInterface $datasource, Collection $collection, $utility)
{
$collection->count()->willReturn(2);
$collection->getValues()->willReturn(['foo', 'bar']);
$utility->applyFilter($datasource, 'data_name_key', 'IN', ['foo', 'bar'])->shouldBeCalled();
$this->apply($datasource, ['value' => $collection, 'type' => AjaxChoiceFilterType::TYPE_CONTAINS]);
}
/**
* @param Archivo $archivo
*/
public function removeArchivo($archivo)
{
if ($this->archivos->contains($archivo)) {
$this->archivos->removeElement($archivo);
$archivo->setDocumentable(null);
}
}
/**
* Remove articles
*
* @param Article $article
*/
public function removeArticle(Article $article)
{
if ($this->articles->contains($article)) {
$this->articles->removeElement($article);
$article->removeCitation($this);
}
}
/**
* @param Collection $collection
*
* @return ArrayCollection
*/
private function filterDeleted(Collection $collection) : ArrayCollection
{
// getValues => reset keys
return new ArrayCollection($collection->filter(function ($entity) {
return !$entity instanceof SoftDeletableInterface || $entity->isDeleted() === false;
})->getValues());
}
private function addCategoryParent(CategoryInterface $category = null, Collection $collection)
{
if (null !== $category) {
$collection->add($category);
$this->addCategoryParent($category->getParent(), $collection);
}
}
/**
* Twitter requires domains without scheme
*
* @param Doctrine\Common\Collections\Collection
*/
public function setDomains(Collection $domains)
{
$remap = $domains->map(function ($item) {
return str_replace(array("https://", "http://"), '', $item);
}, $domains);
$this->domains = $remap;
}
/**
* Remove a given option
*
* @param OptionInterface $option
* @return $this
*/
public function removeOption(OptionInterface $option)
{
if ($this->hasOption($option)) {
$this->options->removeElement($option);
}
return $this;
}
public function addOutpost(Outpost $outpost, $sync = true)
{
$this->outposts->add($outpost);
if ($sync) {
$outpost->setOwner($this, false);
}
}
/**
* @inheritdoc
*/
public function addField(FieldInterface $field)
{
if (is_null($field->getSequential())) {
$field->setSequential($this->getFields()->count());
}
$this->fields->add($field);
return $this;
}
/**
* {@inheritdoc}
*/
public function processConfiguration(Collection $collection)
{
$config = [];
$collection->map(function (PaymentMethodConfigurationInterface $configuration) use(&$config) {
$config[$configuration->getName()] = $configuration->getValue();
});
return $config;
}
/**
* Resets previous photo collection
*
* @param Collection $collection
*/
protected function clearPreviousCollection(Collection $collection)
{
if ($collection->count()) {
foreach ($collection as $item) {
$collection->removeElement($item);
}
}
}
public function getRoles()
{
$roles = array();
foreach ($this->roles->getValues() as $roleObject) {
$roles[] = $roleObject->getName();
}
return $roles;
}
protected function synchronizeOptions(Collection $options)
{
$this->options->map(function (VariantOptionInterface $option) use($options) {
if (false === $options->contains($option)) {
$this->options->removeElement($option);
}
});
}
function its_normalize_method_throw_exception_when_required_field_name_key_is_not_passed($serializer, Collection $collection)
{
$collection->getIterator()->willReturn(new \ArrayIterator([4, 8, 15]));
$serializer->normalize(4, null, ['foo' => 'bar'])->willReturn('Four');
$serializer->normalize(8, null, ['foo' => 'bar'])->willReturn('Eight');
$serializer->normalize(15, null, ['foo' => 'bar'])->willReturn('Fifteen');
$this->shouldThrow(new InvalidArgumentException('Missing required "field_name" context value, got "foo"'))->duringNormalize($collection, null, ['foo' => 'bar']);
}
/**
* Get steps sorted by order.
*
* @return Collection|Step[]
*/
public function getOrderedSteps()
{
$steps = $this->steps->toArray();
usort($steps, function (Step $stepOne, Step $stepTwo) {
return $stepOne->getOrder() >= $stepTwo->getOrder() ? 1 : -1;
});
return new ArrayCollection($steps);
}
/**
* Extracts information from collection and appends it to an array of attributes
*
* @param Collection $collection
* @param array $attributes
*/
protected function extractValues(Collection $collection, &$attributes)
{
$collection->map(function (AttributeValueInterface $attributeValue) use(&$attributes) {
$attribute = $attributeValue->getAttribute();
$attributes[$attribute->getId()]['name'] = $attribute->translate()->getName();
$attributes[$attribute->getId()]['values'][$attributeValue->getId()] = $attributeValue->translate()->getName();
});
}
protected function syncNewAttributes(Collection $attributes)
{
$attributes->map(function (AttributeInterface $attribute) {
if (false === $this->attributes->contains($attribute)) {
$attribute->addValue($this);
}
});
}
private function getCalculator(ShippingMethodInterface $shippingMethod) : ShippingCalculatorInterface
{
$calculator = $shippingMethod->getCalculator();
if (false === $this->calculators->containsKey($calculator)) {
throw new CalculatorNotFoundException($calculator);
}
return $this->calculators->get($calculator);
}
/**
* @param Collection $collection
* @param array $entities
*
* @return Collection
*/
protected function initEntitiesCollectionFromArray(Collection $collection, array $entities)
{
foreach ($entities as $entity) {
$el = new EntityName($entity);
$collection->add($el);
}
return $collection;
}
/**
* Removes all elements from old collection which have not been passed in new collection
*
* @param Collection $oldEntities
* @param Collection $newEntities
*/
protected function synchronizeCollection(Collection $oldCollection, Collection $newCollection)
{
foreach ($oldCollection as $oldEntity) {
if (!$newCollection->contains($oldEntity)) {
$newCollection->removeElement($oldEntity);
}
}
}
/**
* @param User $user
*/
public function removeUser(User $user)
{
if (!$this->users->contains($user)) {
return;
}
$this->users->removeElement($user);
$user->removeGroup($this);
}
