vendor/symfony/form/Extension/DependencyInjection/DependencyInjectionExtension.php line 60

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <[email protected]>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Form\Extension\DependencyInjection;
  14. use Psr\Container\ContainerInterface;
  15. use Symfony\Component\Form\Exception\InvalidArgumentException;
  16. use Symfony\Component\Form\FormExtensionInterface;
  17. use Symfony\Component\Form\FormTypeGuesserChain;
  19. class DependencyInjectionExtension implements FormExtensionInterface
  20. {
  21.     private $guesser;
  22.     private $guesserLoaded = false;
  23.     private $typeContainer;
  24.     private $typeExtensionServices;
  25.     private $guesserServices;
  27.     /**
  28.      * @param iterable[] $typeExtensionServices
  29.      */
  30.     public function __construct(ContainerInterface $typeContainer, array $typeExtensionServices, iterable $guesserServices)
  31.     {
  32.         $this->typeContainer = $typeContainer;
  33.         $this->typeExtensionServices = $typeExtensionServices;
  34.         $this->guesserServices = $guesserServices;
  35.     }
  37.     /**
  38.      * {@inheritdoc}
  39.      */
  40.     public function getType(string $name)
  41.     {
  42.         if (!$this->typeContainer->has($name)) {
  43.             throw new InvalidArgumentException(sprintf('The field type "%s" is not registered in the service container.', $name));
  44.         }
  46.         return $this->typeContainer->get($name);
  47.     }
  49.     /**
  50.      * {@inheritdoc}
  51.      */
  52.     public function hasType(string $name)
  53.     {
  54.         return $this->typeContainer->has($name);
  55.     }
  57.     /**
  58.      * {@inheritdoc}
  59.      */
  60.     public function getTypeExtensions(string $name)
  61.     {
  62.         $extensions = [];
  64.         if (isset($this->typeExtensionServices[$name])) {
  65.             foreach ($this->typeExtensionServices[$name] as $extension) {
  66.                 $extensions[] = $extension;
  68.                 $extendedTypes = [];
  69.                 foreach ($extension::getExtendedTypes() as $extendedType) {
  70.                     $extendedTypes[] = $extendedType;
  71.                 }
  73.                 // validate the result of getExtendedTypes() to ensure it is consistent with the service definition
  74.                 if (!\in_array($name, $extendedTypes, true)) {
  75.                     throw new InvalidArgumentException(sprintf('The extended type "%s" specified for the type extension class "%s" does not match any of the actual extended types (["%s"]).', $name, \get_class($extension), implode('", "', $extendedTypes)));
  76.                 }
  77.             }
  78.         }
  80.         return $extensions;
  81.     }
  83.     /**
  84.      * {@inheritdoc}
  85.      */
  86.     public function hasTypeExtensions(string $name)
  87.     {
  88.         return isset($this->typeExtensionServices[$name]);
  89.     }
  91.     /**
  92.      * {@inheritdoc}
  93.      */
  94.     public function getTypeGuesser()
  95.     {
  96.         if (!$this->guesserLoaded) {
  97.             $this->guesserLoaded = true;
  98.             $guessers = [];
  100.             foreach ($this->guesserServices as $serviceId => $service) {
  101.                 $guessers[] = $service;
  102.             }
  104.             if ($guessers) {
  105.                 $this->guesser = new FormTypeGuesserChain($guessers);
  106.             }
  107.         }
  109.         return $this->guesser;
  110.     }
  111. }