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. }