> Symfony 3 > Doctrine Collections: ManyToMany, Forms & other Complex Relations
Buy Access to Course
15.

Synchronizing Owning & Inverse Sides

Share this awesome video!

|

Keep on Learning!

Start your All-Access Pass

With a Subscription, click any sentence in the script to jump to that part of the video!

Login Subscribe

Ultimately, when we submit... we're still only updating the studiedGenuses property in User, which is the inverse side of this relationship:

238 lines | src/AppBundle/Entity/User.php
// ... lines 1 - 16
class User implements UserInterface
{
// ... lines 19 - 77
/**
* @ORM\ManyToMany(targetEntity="Genus", mappedBy="genusScientists")
// ... line 80
*/
private $studiedGenuses;
// ... lines 83 - 236
}

So, nothing actually saves.

How can we set the owning side? Why not just do it inside the adder and remover methods? At the bottom of addStudiedGenus(), add $genus->addGenusScientist($this):

240 lines | src/AppBundle/Entity/User.php
// ... lines 1 - 16
class User implements UserInterface
{
// ... lines 19 - 223
public function addStudiedGenus(Genus $genus)
{
if ($this->studiedGenuses->contains($genus)) {
return;
}
$this->studiedGenuses[] = $genus;
$genus->addGenusScientist($this);
}
// ... lines 233 - 238
}

Booya, we just set the owning side of the relationship!

In removeStudiedGenus(), do the same thing: $genus->removeGenusScientist($this):

240 lines | src/AppBundle/Entity/User.php
// ... lines 1 - 16
class User implements UserInterface
{
// ... lines 19 - 233
public function removeStudiedGenus(Genus $genus)
{
$this->studiedGenuses->removeElement($genus);
$genus->removeGenusScientist($this);
}
}

So.... yea, that's all we need to do. Go back to the form, uncheck a genus, check a genus and hit update. It's alive!!!

We didn't need to add a lot of code to get this to work... but this situation has caused many developers to lose countless hours trying to get their relationship to save. To summarize: if you're modifying the inverse side of a relationship, set the by_reference form option to false, create an adder and remover function, and make sure you set the owning side of the relationship in each. That is it.

Synchronizing Both Sides

So, we're done! Well, technically we are done, but there is one last, tiny, teeny detail that I'd like to perfect. In Genus, when we call addGenusScientist(), it would be nice if we also updated this User to know that this Genus is now being studied by it. In other words, it would be nice if we called $user->addStudiedGenus($this):

201 lines | src/AppBundle/Entity/Genus.php
// ... lines 1 - 14
class Genus
{
// ... lines 17 - 174
public function addGenusScientist(User $user)
{
if ($this->genusScientists->contains($user)) {
return;
}
$this->genusScientists[] = $user;
// not needed for persistence, just keeping both sides in sync
$user->addStudiedGenus($this);
}
// ... lines 185 - 199
}

I'm also going to add a note: this is not needed for persistence, but it might save you from an edge-case bug. Suppose we called $genus->addGenusScientist() to link a User to the Genus. Then later, during the same request - that's important - we have that same User object, and we call getStudiedGenuses(). We would want the Genus that was just linked to be in that collection. This does that! We're guaranteeing that both sides of the relationship stay synchronized.

Do the same thing down in the remover: $user->removeStudiedGenus($this):

201 lines | src/AppBundle/Entity/Genus.php
// ... lines 1 - 14
class Genus
{
// ... lines 17 - 185
public function removeGenusScientist(User $user)
{
$this->genusScientists->removeElement($user);
// not needed for persistence, just keeping both sides in sync
$user->removeStudiedGenus($this);
}
// ... lines 192 - 199
}

Have Fun and Avoid Infinite Recursion!

That's great! Oh, except for one thing I just introduced: infinite recursion! When we call removeStudiedGenus(), that calls removeGenusScientist(), which calls removeStudiedGenus(), and so on... forever. And we are too busy to let our scripts run forever!

The fix is easy - I was being lazy. Add an if statement in the remove functions, like if !$this->studiedGenuses->contains($genus), then just return:

244 lines | src/AppBundle/Entity/User.php
// ... lines 1 - 16
class User implements UserInterface
{
// ... lines 19 - 233
public function removeStudiedGenus(Genus $genus)
{
if (!$this->studiedGenuses->contains($genus)) {
return;
}
$this->studiedGenuses->removeElement($genus);
$genus->removeGenusScientist($this);
}
}

In other words, if the $genus is not in the studiedGenuses array, there's no reason to try to remove it.

Inside Genus, do the exact same thing: if !$this->genusScientists->contains($user), then return:

205 lines | src/AppBundle/Entity/Genus.php
// ... lines 1 - 14
class Genus
{
// ... lines 17 - 185
public function removeGenusScientist(User $user)
{
if (!$this->genusScientists->contains($user)) {
return;
}
$this->genusScientists->removeElement($user);
// not needed for persistence, just keeping both sides in sync
$user->removeStudiedGenus($this);
}
// ... lines 196 - 203
}

Bye bye recursion.

Head back: uncheck a few genuses, check a few more and.... save! It works perfectly. We don't really notice this last perfection... but it may help us out in the future.