vendor/symfony/form/FormRegistry.php line 122

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  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;
  14. use Symfony\Component\Form\Exception\ExceptionInterface;
  15. use Symfony\Component\Form\Exception\InvalidArgumentException;
  16. use Symfony\Component\Form\Exception\LogicException;
  17. use Symfony\Component\Form\Exception\UnexpectedTypeException;
  19. /**
  20.  * The central registry of the Form component.
  21.  *
  22.  * @author Bernhard Schussek <bschussek@gmail.com>
  23.  */
  24. class FormRegistry implements FormRegistryInterface
  25. {
  26.     /**
  27.      * @var FormExtensionInterface[]
  28.      */
  29.     private $extensions = [];
  31.     /**
  32.      * @var ResolvedFormTypeInterface[]
  33.      */
  34.     private $types = [];
  36.     /**
  37.      * @var FormTypeGuesserInterface|false|null
  38.      */
  39.     private $guesser = false;
  41.     /**
  42.      * @var ResolvedFormTypeFactoryInterface
  43.      */
  44.     private $resolvedTypeFactory;
  46.     private $checkedTypes = [];
  48.     /**
  49.      * @param FormExtensionInterface[] $extensions
  50.      *
  51.      * @throws UnexpectedTypeException if any extension does not implement FormExtensionInterface
  52.      */
  53.     public function __construct(array $extensions, ResolvedFormTypeFactoryInterface $resolvedTypeFactory)
  54.     {
  55.         foreach ($extensions as $extension) {
  56.             if (!$extension instanceof FormExtensionInterface) {
  57.                 throw new UnexpectedTypeException($extension, FormExtensionInterface::class);
  58.             }
  59.         }
  61.         $this->extensions = $extensions;
  62.         $this->resolvedTypeFactory = $resolvedTypeFactory;
  63.     }
  65.     /**
  66.      * {@inheritdoc}
  67.      */
  68.     public function getType(string $name)
  69.     {
  70.         if (!isset($this->types[$name])) {
  71.             $type = null;
  73.             foreach ($this->extensions as $extension) {
  74.                 if ($extension->hasType($name)) {
  75.                     $type = $extension->getType($name);
  76.                     break;
  77.                 }
  78.             }
  80.             if (!$type) {
  81.                 // Support fully-qualified class names
  82.                 if (!class_exists($name)) {
  83.                     throw new InvalidArgumentException(sprintf('Could not load type "%s": class does not exist.', $name));
  84.                 }
  85.                 if (!is_subclass_of($name, FormTypeInterface::class)) {
  86.                     throw new InvalidArgumentException(sprintf('Could not load type "%s": class does not implement "Symfony\Component\Form\FormTypeInterface".', $name));
  87.                 }
  89.                 $type = new $name();
  90.             }
  92.             $this->types[$name] = $this->resolveType($type);
  93.         }
  95.         return $this->types[$name];
  96.     }
  98.     /**
  99.      * Wraps a type into a ResolvedFormTypeInterface implementation and connects it with its parent type.
  100.      */
  101.     private function resolveType(FormTypeInterface $type): ResolvedFormTypeInterface
  102.     {
  103.         $parentType = $type->getParent();
  104.         $fqcn = \get_class($type);
  106.         if (isset($this->checkedTypes[$fqcn])) {
  107.             $types = implode(' > ', array_merge(array_keys($this->checkedTypes), [$fqcn]));
  108.             throw new LogicException(sprintf('Circular reference detected for form type "%s" (%s).', $fqcn, $types));
  109.         }
  111.         $this->checkedTypes[$fqcn] = true;
  113.         $typeExtensions = [];
  114.         try {
  115.             foreach ($this->extensions as $extension) {
  116.                 $typeExtensions[] = $extension->getTypeExtensions($fqcn);
  117.             }
  119.             return $this->resolvedTypeFactory->createResolvedType(
  120.                 $type,
  121.                 array_merge([], ...$typeExtensions),
  122.                 $parentType ? $this->getType($parentType) : null
  123.             );
  124.         } finally {
  125.             unset($this->checkedTypes[$fqcn]);
  126.         }
  127.     }
  129.     /**
  130.      * {@inheritdoc}
  131.      */
  132.     public function hasType(string $name)
  133.     {
  134.         if (isset($this->types[$name])) {
  135.             return true;
  136.         }
  138.         try {
  139.             $this->getType($name);
  140.         } catch (ExceptionInterface $e) {
  141.             return false;
  142.         }
  144.         return true;
  145.     }
  147.     /**
  148.      * {@inheritdoc}
  149.      */
  150.     public function getTypeGuesser()
  151.     {
  152.         if (false === $this->guesser) {
  153.             $guessers = [];
  155.             foreach ($this->extensions as $extension) {
  156.                 $guesser = $extension->getTypeGuesser();
  158.                 if ($guesser) {
  159.                     $guessers[] = $guesser;
  160.                 }
  161.             }
  163.             $this->guesser = !empty($guessers) ? new FormTypeGuesserChain($guessers) : null;
  164.         }
  166.         return $this->guesser;
  167.     }
  169.     /**
  170.      * {@inheritdoc}
  171.      */
  172.     public function getExtensions()
  173.     {
  174.         return $this->extensions;
  175.     }
  176. }