vendor/doctrine/orm/lib/Doctrine/ORM/Tools/ResolveTargetEntityListener.php line 61

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Tools;
  7. use Doctrine\Common\EventSubscriber;
  8. use Doctrine\ORM\Event\LoadClassMetadataEventArgs;
  9. use Doctrine\ORM\Event\OnClassMetadataNotFoundEventArgs;
  10. use Doctrine\ORM\Events;
  11. use Doctrine\ORM\Mapping\ClassMetadata;
  13. use function array_key_exists;
  14. use function array_replace_recursive;
  15. use function ltrim;
  17. /**
  18.  * ResolveTargetEntityListener
  19.  *
  20.  * Mechanism to overwrite interfaces or classes specified as association
  21.  * targets.
  22.  *
  23.  * @psalm-import-type AssociationMapping from ClassMetadata
  24.  */
  25. class ResolveTargetEntityListener implements EventSubscriber
  26. {
  27.     /** @var mixed[][] indexed by original entity name */
  28.     private $resolveTargetEntities = [];
  30.     /**
  31.      * {@inheritDoc}
  32.      */
  33.     public function getSubscribedEvents()
  34.     {
  35.         return [
  36.             Events::loadClassMetadata,
  37.             Events::onClassMetadataNotFound,
  38.         ];
  39.     }
  41.     /**
  42.      * Adds a target-entity class name to resolve to a new class name.
  43.      *
  44.      * @param string $originalEntity
  45.      * @param string $newEntity
  46.      * @psalm-param array<string, mixed> $mapping
  47.      *
  48.      * @return void
  49.      */
  50.     public function addResolveTargetEntity($originalEntity, $newEntity, array $mapping)
  51.     {
  52.         $mapping['targetEntity']                                   = ltrim($newEntity, '\\');
  53.         $this->resolveTargetEntities[ltrim($originalEntity, '\\')] = $mapping;
  54.     }
  56.     /**
  57.      * @internal this is an event callback, and should not be called directly
  58.      *
  59.      * @return void
  60.      */
  61.     public function onClassMetadataNotFound(OnClassMetadataNotFoundEventArgs $args)
  62.     {
  63.         if (array_key_exists($args->getClassName(), $this->resolveTargetEntities)) {
  64.             $args->setFoundMetadata(
  65.                 $args
  66.                     ->getObjectManager()
  67.                     ->getClassMetadata($this->resolveTargetEntities[$args->getClassName()]['targetEntity'])
  68.             );
  69.         }
  70.     }
  72.     /**
  73.      * Processes event and resolves new target entity names.
  74.      *
  75.      * @internal this is an event callback, and should not be called directly
  76.      *
  77.      * @return void
  78.      */
  79.     public function loadClassMetadata(LoadClassMetadataEventArgs $args)
  80.     {
  81.         $cm = $args->getClassMetadata();
  83.         foreach ($cm->associationMappings as $mapping) {
  84.             if (isset($this->resolveTargetEntities[$mapping['targetEntity']])) {
  85.                 $this->remapAssociation($cm, $mapping);
  86.             }
  87.         }
  89.         foreach ($this->resolveTargetEntities as $interface => $data) {
  90.             if ($data['targetEntity'] === $cm->getName()) {
  91.                 $args->getEntityManager()->getMetadataFactory()->setMetadataFor($interface, $cm);
  92.             }
  93.         }
  95.         foreach ($cm->discriminatorMap as $value => $class) {
  96.             if (isset($this->resolveTargetEntities[$class])) {
  97.                 $cm->addDiscriminatorMapClass($value, $this->resolveTargetEntities[$class]['targetEntity']);
  98.             }
  99.         }
  100.     }
  102.     /** @param AssociationMapping $mapping */
  103.     private function remapAssociation(ClassMetadata $classMetadata, array $mapping): void
  104.     {
  105.         $newMapping              = $this->resolveTargetEntities[$mapping['targetEntity']];
  106.         $newMapping              = array_replace_recursive($mapping, $newMapping);
  107.         $newMapping['fieldName'] = $mapping['fieldName'];
  109.         unset($classMetadata->associationMappings[$mapping['fieldName']]);
  111.         switch ($mapping['type']) {
  112.             case ClassMetadata::MANY_TO_MANY:
  113.                 $classMetadata->mapManyToMany($newMapping);
  114.                 break;
  115.             case ClassMetadata::MANY_TO_ONE:
  116.                 $classMetadata->mapManyToOne($newMapping);
  117.                 break;
  118.             case ClassMetadata::ONE_TO_MANY:
  119.                 $classMetadata->mapOneToMany($newMapping);
  120.                 break;
  121.             case ClassMetadata::ONE_TO_ONE:
  122.                 $classMetadata->mapOneToOne($newMapping);
  123.                 break;
  124.         }
  125.     }
  126. }