vendor/symfony/form/FormRegistry.php line 64

  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 array $extensions = [];
  31.     /**
  32.      * @var ResolvedFormTypeInterface[]
  33.      */
  34.     private array $types = [];
  36.     private FormTypeGuesserInterface|null|false $guesser = false;
  37.     private ResolvedFormTypeFactoryInterface $resolvedTypeFactory;
  38.     private array $checkedTypes = [];
  40.     /**
  41.      * @param FormExtensionInterface[] $extensions
  42.      *
  43.      * @throws UnexpectedTypeException if any extension does not implement FormExtensionInterface
  44.      */
  45.     public function __construct(array $extensions, ResolvedFormTypeFactoryInterface $resolvedTypeFactory)
  46.     {
  47.         foreach ($extensions as $extension) {
  48.             if (!$extension instanceof FormExtensionInterface) {
  49.                 throw new UnexpectedTypeException($extension, FormExtensionInterface::class);
  50.             }
  51.         }
  53.         $this->extensions = $extensions;
  54.         $this->resolvedTypeFactory = $resolvedTypeFactory;
  55.     }
  57.     public function getType(string $name): ResolvedFormTypeInterface
  58.     {
  59.         if (!isset($this->types[$name])) {
  60.             $type = null;
  62.             foreach ($this->extensions as $extension) {
  63.                 if ($extension->hasType($name)) {
  64.                     $type = $extension->getType($name);
  65.                     break;
  66.                 }
  67.             }
  69.             if (!$type) {
  70.                 // Support fully-qualified class names
  71.                 if (!class_exists($name)) {
  72.                     throw new InvalidArgumentException(sprintf('Could not load type "%s": class does not exist.', $name));
  73.                 }
  74.                 if (!is_subclass_of($name, FormTypeInterface::class)) {
  75.                     throw new InvalidArgumentException(sprintf('Could not load type "%s": class does not implement "Symfony\Component\Form\FormTypeInterface".', $name));
  76.                 }
  78.                 $type = new $name();
  79.             }
  81.             $this->types[$name] = $this->resolveType($type);
  82.         }
  84.         return $this->types[$name];
  85.     }
  87.     /**
  88.      * Wraps a type into a ResolvedFormTypeInterface implementation and connects it with its parent type.
  89.      */
  90.     private function resolveType(FormTypeInterface $type): ResolvedFormTypeInterface
  91.     {
  92.         $parentType = $type->getParent();
  93.         $fqcn = $type::class;
  95.         if (isset($this->checkedTypes[$fqcn])) {
  96.             $types = implode(' > ', array_merge(array_keys($this->checkedTypes), [$fqcn]));
  97.             throw new LogicException(sprintf('Circular reference detected for form type "%s" (%s).', $fqcn, $types));
  98.         }
  100.         $this->checkedTypes[$fqcn] = true;
  102.         $typeExtensions = [];
  103.         try {
  104.             foreach ($this->extensions as $extension) {
  105.                 $typeExtensions[] = $extension->getTypeExtensions($fqcn);
  106.             }
  108.             return $this->resolvedTypeFactory->createResolvedType(
  109.                 $type,
  110.                 array_merge([], ...$typeExtensions),
  111.                 $parentType ? $this->getType($parentType) : null
  112.             );
  113.         } finally {
  114.             unset($this->checkedTypes[$fqcn]);
  115.         }
  116.     }
  118.     public function hasType(string $name): bool
  119.     {
  120.         if (isset($this->types[$name])) {
  121.             return true;
  122.         }
  124.         try {
  125.             $this->getType($name);
  126.         } catch (ExceptionInterface) {
  127.             return false;
  128.         }
  130.         return true;
  131.     }
  133.     public function getTypeGuesser(): ?FormTypeGuesserInterface
  134.     {
  135.         if (false === $this->guesser) {
  136.             $guessers = [];
  138.             foreach ($this->extensions as $extension) {
  139.                 $guesser = $extension->getTypeGuesser();
  141.                 if ($guesser) {
  142.                     $guessers[] = $guesser;
  143.                 }
  144.             }
  146.             $this->guesser = $guessers ? new FormTypeGuesserChain($guessers) : null;
  147.         }
  149.         return $this->guesser;
  150.     }
  152.     public function getExtensions(): array
  153.     {
  154.         return $this->extensions;
  155.     }
  156. }