vendor/symfony/form/FormRegistry.php line 94

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