vendor/symfony/form/FormRegistry.php line 94

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;
  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 <[email protected]>
  23.  */
  24. class FormRegistry implements FormRegistryInterface
  25. {
  26.     /**
  27.      * Extensions.
  28.      *
  29.      * @var FormExtensionInterface[]
  30.      */
  31.     private $extensions = [];
  33.     /**
  34.      * @var ResolvedFormTypeInterface[]
  35.      */
  36.     private $types = [];
  38.     /**
  39.      * @var FormTypeGuesserInterface|false|null
  40.      */
  41.     private $guesser = false;
  43.     /**
  44.      * @var ResolvedFormTypeFactoryInterface
  45.      */
  46.     private $resolvedTypeFactory;
  48.     private $checkedTypes = [];
  50.     /**
  51.      * @param FormExtensionInterface[] $extensions An array of FormExtensionInterface
  52.      *
  53.      * @throws UnexpectedTypeException if any extension does not implement FormExtensionInterface
  54.      */
  55.     public function __construct(array $extensions, ResolvedFormTypeFactoryInterface $resolvedTypeFactory)
  56.     {
  57.         foreach ($extensions as $extension) {
  58.             if (!$extension instanceof FormExtensionInterface) {
  59.                 throw new UnexpectedTypeException($extension, 'Symfony\Component\Form\FormExtensionInterface');
  60.             }
  61.         }
  63.         $this->extensions = $extensions;
  64.         $this->resolvedTypeFactory = $resolvedTypeFactory;
  65.     }
  67.     /**
  68.      * {@inheritdoc}
  69.      */
  70.     public function getType($name)
  71.     {
  72.         if (!isset($this->types[$name])) {
  73.             $type = null;
  75.             foreach ($this->extensions as $extension) {
  76.                 if ($extension->hasType($name)) {
  77.                     $type = $extension->getType($name);
  78.                     break;
  79.                 }
  80.             }
  82.             if (!$type) {
  83.                 // Support fully-qualified class names
  84.                 if (!class_exists($name)) {
  85.                     throw new InvalidArgumentException(sprintf('Could not load type "%s": class does not exist.', $name));
  86.                 }
  87.                 if (!is_subclass_of($name, 'Symfony\Component\Form\FormTypeInterface')) {
  88.                     throw new InvalidArgumentException(sprintf('Could not load type "%s": class does not implement "Symfony\Component\Form\FormTypeInterface".', $name));
  89.                 }
  91.                 $type = new $name();
  92.             }
  94.             $this->types[$name] = $this->resolveType($type);
  95.         }
  97.         return $this->types[$name];
  98.     }
  100.     /**
  101.      * Wraps a type into a ResolvedFormTypeInterface implementation and connects it with its parent type.
  102.      */
  103.     private function resolveType(FormTypeInterface $type): ResolvedFormTypeInterface
  104.     {
  105.         $typeExtensions = [];
  106.         $parentType = $type->getParent();
  107.         $fqcn = \get_class($type);
  109.         if (isset($this->checkedTypes[$fqcn])) {
  110.             $types = implode(' > ', array_merge(array_keys($this->checkedTypes), [$fqcn]));
  111.             throw new LogicException(sprintf('Circular reference detected for form type "%s" (%s).', $fqcn, $types));
  112.         }
  114.         $this->checkedTypes[$fqcn] = true;
  116.         try {
  117.             foreach ($this->extensions as $extension) {
  118.                 $typeExtensions = array_merge(
  119.                     $typeExtensions,
  120.                     $extension->getTypeExtensions($fqcn)
  121.                 );
  122.             }
  124.             return $this->resolvedTypeFactory->createResolvedType(
  125.                 $type,
  126.                 $typeExtensions,
  127.                 $parentType ? $this->getType($parentType) : null
  128.             );
  129.         } finally {
  130.             unset($this->checkedTypes[$fqcn]);
  131.         }
  132.     }
  134.     /**
  135.      * {@inheritdoc}
  136.      */
  137.     public function hasType($name)
  138.     {
  139.         if (isset($this->types[$name])) {
  140.             return true;
  141.         }
  143.         try {
  144.             $this->getType($name);
  145.         } catch (ExceptionInterface $e) {
  146.             return false;
  147.         }
  149.         return true;
  150.     }
  152.     /**
  153.      * {@inheritdoc}
  154.      */
  155.     public function getTypeGuesser()
  156.     {
  157.         if (false === $this->guesser) {
  158.             $guessers = [];
  160.             foreach ($this->extensions as $extension) {
  161.                 $guesser = $extension->getTypeGuesser();
  163.                 if ($guesser) {
  164.                     $guessers[] = $guesser;
  165.                 }
  166.             }
  168.             $this->guesser = !empty($guessers) ? new FormTypeGuesserChain($guessers) : null;
  169.         }
  171.         return $this->guesser;
  172.     }
  174.     /**
  175.      * {@inheritdoc}
  176.      */
  177.     public function getExtensions()
  178.     {
  179.         return $this->extensions;
  180.     }
  181. }