vendor/symfony/form/Form.php line 72

  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\Event\PostSetDataEvent;
  15. use Symfony\Component\Form\Event\PostSubmitEvent;
  16. use Symfony\Component\Form\Event\PreSetDataEvent;
  17. use Symfony\Component\Form\Event\PreSubmitEvent;
  18. use Symfony\Component\Form\Event\SubmitEvent;
  19. use Symfony\Component\Form\Exception\AlreadySubmittedException;
  20. use Symfony\Component\Form\Exception\LogicException;
  21. use Symfony\Component\Form\Exception\OutOfBoundsException;
  22. use Symfony\Component\Form\Exception\RuntimeException;
  23. use Symfony\Component\Form\Exception\TransformationFailedException;
  24. use Symfony\Component\Form\Exception\UnexpectedTypeException;
  25. use Symfony\Component\Form\Extension\Core\Type\TextType;
  26. use Symfony\Component\Form\Util\FormUtil;
  27. use Symfony\Component\Form\Util\InheritDataAwareIterator;
  28. use Symfony\Component\Form\Util\OrderedHashMap;
  29. use Symfony\Component\PropertyAccess\PropertyPath;
  30. use Symfony\Component\PropertyAccess\PropertyPathInterface;
  32. /**
  33.  * Form represents a form.
  34.  *
  35.  * To implement your own form fields, you need to have a thorough understanding
  36.  * of the data flow within a form. A form stores its data in three different
  37.  * representations:
  38.  *
  39.  *   (1) the "model" format required by the form's object
  40.  *   (2) the "normalized" format for internal processing
  41.  *   (3) the "view" format used for display simple fields
  42.  *       or map children model data for compound fields
  43.  *
  44.  * A date field, for example, may store a date as "Y-m-d" string (1) in the
  45.  * object. To facilitate processing in the field, this value is normalized
  46.  * to a DateTime object (2). In the HTML representation of your form, a
  47.  * localized string (3) may be presented to and modified by the user, or it could be an array of values
  48.  * to be mapped to choices fields.
  49.  *
  50.  * In most cases, format (1) and format (2) will be the same. For example,
  51.  * a checkbox field uses a Boolean value for both internal processing and
  52.  * storage in the object. In these cases you need to set a view transformer
  53.  * to convert between formats (2) and (3). You can do this by calling
  54.  * addViewTransformer().
  55.  *
  56.  * In some cases though it makes sense to make format (1) configurable. To
  57.  * demonstrate this, let's extend our above date field to store the value
  58.  * either as "Y-m-d" string or as timestamp. Internally we still want to
  59.  * use a DateTime object for processing. To convert the data from string/integer
  60.  * to DateTime you can set a model transformer by calling
  61.  * addModelTransformer(). The normalized data is then converted to the displayed
  62.  * data as described before.
  63.  *
  64.  * The conversions (1) -> (2) -> (3) use the transform methods of the transformers.
  65.  * The conversions (3) -> (2) -> (1) use the reverseTransform methods of the transformers.
  66.  *
  67.  * @author Fabien Potencier <fabien@symfony.com>
  68.  * @author Bernhard Schussek <bschussek@gmail.com>
  69.  *
  70.  * @implements \IteratorAggregate<string, FormInterface>
  71.  */
  72. class Form implements \IteratorAggregate, FormInterface, ClearableErrorsInterface
  73. {
  74.     private FormConfigInterface $config;
  75.     private ?FormInterface $parent = null;
  77.     /**
  78.      * A map of FormInterface instances.
  79.      *
  80.      * @var OrderedHashMap<FormInterface>
  81.      */
  82.     private OrderedHashMap $children;
  84.     /**
  85.      * @var FormError[]
  86.      */
  87.     private array $errors = [];
  89.     private bool $submitted = false;
  91.     /**
  92.      * The button that was used to submit the form.
  93.      */
  94.     private FormInterface|ClickableInterface|null $clickedButton = null;
  96.     private mixed $modelData = null;
  97.     private mixed $normData = null;
  98.     private mixed $viewData = null;
  100.     /**
  101.      * The submitted values that don't belong to any children.
  102.      */
  103.     private array $extraData = [];
  105.     /**
  106.      * The transformation failure generated during submission, if any.
  107.      */
  108.     private ?TransformationFailedException $transformationFailure = null;
  110.     /**
  111.      * Whether the form's data has been initialized.
  112.      *
  113.      * When the data is initialized with its default value, that default value
  114.      * is passed through the transformer chain in order to synchronize the
  115.      * model, normalized and view format for the first time. This is done
  116.      * lazily in order to save performance when {@link setData()} is called
  117.      * manually, making the initialization with the configured default value
  118.      * superfluous.
  119.      */
  120.     private bool $defaultDataSet = false;
  122.     /**
  123.      * Whether setData() is currently being called.
  124.      */
  125.     private bool $lockSetData = false;
  127.     private string $name = '';
  129.     /**
  130.      * Whether the form inherits its underlying data from its parent.
  131.      */
  132.     private bool $inheritData;
  134.     private ?PropertyPathInterface $propertyPath = null;
  136.     /**
  137.      * @throws LogicException if a data mapper is not provided for a compound form
  138.      */
  139.     public function __construct(FormConfigInterface $config)
  140.     {
  141.         // Compound forms always need a data mapper, otherwise calls to
  142.         // `setData` and `add` will not lead to the correct population of
  143.         // the child forms.
  144.         if ($config->getCompound() && !$config->getDataMapper()) {
  145.             throw new LogicException('Compound forms need a data mapper.');
  146.         }
  148.         // If the form inherits the data from its parent, it is not necessary
  149.         // to call setData() with the default data.
  150.         if ($this->inheritData = $config->getInheritData()) {
  151.             $this->defaultDataSet = true;
  152.         }
  154.         $this->config = $config;
  155.         $this->children = new OrderedHashMap();
  156.         $this->name = $config->getName();
  157.     }
  159.     public function __clone()
  160.     {
  161.         $this->children = clone $this->children;
  163.         foreach ($this->children as $key => $child) {
  164.             $this->children[$key] = clone $child;
  165.         }
  166.     }
  168.     public function getConfig(): FormConfigInterface
  169.     {
  170.         return $this->config;
  171.     }
  173.     public function getName(): string
  174.     {
  175.         return $this->name;
  176.     }
  178.     public function getPropertyPath(): ?PropertyPathInterface
  179.     {
  180.         if ($this->propertyPath || $this->propertyPath = $this->config->getPropertyPath()) {
  181.             return $this->propertyPath;
  182.         }
  184.         if ('' === $this->name) {
  185.             return null;
  186.         }
  188.         $parent = $this->parent;
  190.         while ($parent?->getConfig()->getInheritData()) {
  191.             $parent = $parent->getParent();
  192.         }
  194.         if ($parent && null === $parent->getConfig()->getDataClass()) {
  195.             $this->propertyPath = new PropertyPath('['.$this->name.']');
  196.         } else {
  197.             $this->propertyPath = new PropertyPath($this->name);
  198.         }
  200.         return $this->propertyPath;
  201.     }
  203.     public function isRequired(): bool
  204.     {
  205.         if (null === $this->parent || $this->parent->isRequired()) {
  206.             return $this->config->getRequired();
  207.         }
  209.         return false;
  210.     }
  212.     public function isDisabled(): bool
  213.     {
  214.         if (null === $this->parent || !$this->parent->isDisabled()) {
  215.             return $this->config->getDisabled();
  216.         }
  218.         return true;
  219.     }
  221.     public function setParent(FormInterface $parent = null): static
  222.     {
  223.         if (1 > \func_num_args()) {
  224.             trigger_deprecation('symfony/form', '6.2', 'Calling "%s()" without any arguments is deprecated, pass null explicitly instead.', __METHOD__);
  225.         }
  227.         if ($this->submitted) {
  228.             throw new AlreadySubmittedException('You cannot set the parent of a submitted form.');
  229.         }
  231.         if (null !== $parent && '' === $this->name) {
  232.             throw new LogicException('A form with an empty name cannot have a parent form.');
  233.         }
  235.         $this->parent = $parent;
  237.         return $this;
  238.     }
  240.     public function getParent(): ?FormInterface
  241.     {
  242.         return $this->parent;
  243.     }
  245.     public function getRoot(): FormInterface
  246.     {
  247.         return $this->parent ? $this->parent->getRoot() : $this;
  248.     }
  250.     public function isRoot(): bool
  251.     {
  252.         return null === $this->parent;
  253.     }
  255.     public function setData(mixed $modelData): static
  256.     {
  257.         // If the form is submitted while disabled, it is set to submitted, but the data is not
  258.         // changed. In such cases (i.e. when the form is not initialized yet) don't
  259.         // abort this method.
  260.         if ($this->submitted && $this->defaultDataSet) {
  261.             throw new AlreadySubmittedException('You cannot change the data of a submitted form.');
  262.         }
  264.         // If the form inherits its parent's data, disallow data setting to
  265.         // prevent merge conflicts
  266.         if ($this->inheritData) {
  267.             throw new RuntimeException('You cannot change the data of a form inheriting its parent data.');
  268.         }
  270.         // Don't allow modifications of the configured data if the data is locked
  271.         if ($this->config->getDataLocked() && $modelData !== $this->config->getData()) {
  272.             return $this;
  273.         }
  275.         if (\is_object($modelData) && !$this->config->getByReference()) {
  276.             $modelData = clone $modelData;
  277.         }
  279.         if ($this->lockSetData) {
  280.             throw new RuntimeException('A cycle was detected. Listeners to the PRE_SET_DATA event must not call setData(). You should call setData() on the FormEvent object instead.');
  281.         }
  283.         $this->lockSetData = true;
  284.         $dispatcher = $this->config->getEventDispatcher();
  286.         // Hook to change content of the model data before transformation and mapping children
  287.         if ($dispatcher->hasListeners(FormEvents::PRE_SET_DATA)) {
  288.             $event = new PreSetDataEvent($this, $modelData);
  289.             $dispatcher->dispatch($event, FormEvents::PRE_SET_DATA);
  290.             $modelData = $event->getData();
  291.         }
  293.         // Treat data as strings unless a transformer exists
  294.         if (\is_scalar($modelData) && !$this->config->getViewTransformers() && !$this->config->getModelTransformers()) {
  295.             $modelData = (string) $modelData;
  296.         }
  298.         // Synchronize representations - must not change the content!
  299.         // Transformation exceptions are not caught on initialization
  300.         $normData = $this->modelToNorm($modelData);
  301.         $viewData = $this->normToView($normData);
  303.         // Validate if view data matches data class (unless empty)
  304.         if (!FormUtil::isEmpty($viewData)) {
  305.             $dataClass = $this->config->getDataClass();
  307.             if (null !== $dataClass && !$viewData instanceof $dataClass) {
  308.                 $actualType = get_debug_type($viewData);
  310.                 throw new LogicException('The form\'s view data is expected to be a "'.$dataClass.'", but it is a "'.$actualType.'". You can avoid this error by setting the "data_class" option to null or by adding a view transformer that transforms "'.$actualType.'" to an instance of "'.$dataClass.'".');
  311.             }
  312.         }
  314.         $this->modelData = $modelData;
  315.         $this->normData = $normData;
  316.         $this->viewData = $viewData;
  317.         $this->defaultDataSet = true;
  318.         $this->lockSetData = false;
  320.         // Compound forms don't need to invoke this method if they don't have children
  321.         if (\count($this->children) > 0) {
  322.             // Update child forms from the data (unless their config data is locked)
  323.             $this->config->getDataMapper()->mapDataToForms($viewData, new \RecursiveIteratorIterator(new InheritDataAwareIterator($this->children)));
  324.         }
  326.         if ($dispatcher->hasListeners(FormEvents::POST_SET_DATA)) {
  327.             $event = new PostSetDataEvent($this, $modelData);
  328.             $dispatcher->dispatch($event, FormEvents::POST_SET_DATA);
  329.         }
  331.         return $this;
  332.     }
  334.     public function getData(): mixed
  335.     {
  336.         if ($this->inheritData) {
  337.             if (!$this->parent) {
  338.                 throw new RuntimeException('The form is configured to inherit its parent\'s data, but does not have a parent.');
  339.             }
  341.             return $this->parent->getData();
  342.         }
  344.         if (!$this->defaultDataSet) {
  345.             if ($this->lockSetData) {
  346.                 throw new RuntimeException('A cycle was detected. Listeners to the PRE_SET_DATA event must not call getData() if the form data has not already been set. You should call getData() on the FormEvent object instead.');
  347.             }
  349.             $this->setData($this->config->getData());
  350.         }
  352.         return $this->modelData;
  353.     }
  355.     public function getNormData(): mixed
  356.     {
  357.         if ($this->inheritData) {
  358.             if (!$this->parent) {
  359.                 throw new RuntimeException('The form is configured to inherit its parent\'s data, but does not have a parent.');
  360.             }
  362.             return $this->parent->getNormData();
  363.         }
  365.         if (!$this->defaultDataSet) {
  366.             if ($this->lockSetData) {
  367.                 throw new RuntimeException('A cycle was detected. Listeners to the PRE_SET_DATA event must not call getNormData() if the form data has not already been set.');
  368.             }
  370.             $this->setData($this->config->getData());
  371.         }
  373.         return $this->normData;
  374.     }
  376.     public function getViewData(): mixed
  377.     {
  378.         if ($this->inheritData) {
  379.             if (!$this->parent) {
  380.                 throw new RuntimeException('The form is configured to inherit its parent\'s data, but does not have a parent.');
  381.             }
  383.             return $this->parent->getViewData();
  384.         }
  386.         if (!$this->defaultDataSet) {
  387.             if ($this->lockSetData) {
  388.                 throw new RuntimeException('A cycle was detected. Listeners to the PRE_SET_DATA event must not call getViewData() if the form data has not already been set.');
  389.             }
  391.             $this->setData($this->config->getData());
  392.         }
  394.         return $this->viewData;
  395.     }
  397.     public function getExtraData(): array
  398.     {
  399.         return $this->extraData;
  400.     }
  402.     public function initialize(): static
  403.     {
  404.         if (null !== $this->parent) {
  405.             throw new RuntimeException('Only root forms should be initialized.');
  406.         }
  408.         // Guarantee that the *_SET_DATA events have been triggered once the
  409.         // form is initialized. This makes sure that dynamically added or
  410.         // removed fields are already visible after initialization.
  411.         if (!$this->defaultDataSet) {
  412.             $this->setData($this->config->getData());
  413.         }
  415.         return $this;
  416.     }
  418.     public function handleRequest(mixed $request = null): static
  419.     {
  420.         $this->config->getRequestHandler()->handleRequest($this, $request);
  422.         return $this;
  423.     }
  425.     public function submit(mixed $submittedData, bool $clearMissing = true): static
  426.     {
  427.         if ($this->submitted) {
  428.             throw new AlreadySubmittedException('A form can only be submitted once.');
  429.         }
  431.         // Initialize errors in the very beginning so we're sure
  432.         // they are collectable during submission only
  433.         $this->errors = [];
  435.         // Obviously, a disabled form should not change its data upon submission.
  436.         if ($this->isDisabled()) {
  437.             $this->submitted = true;
  439.             return $this;
  440.         }
  442.         // The data must be initialized if it was not initialized yet.
  443.         // This is necessary to guarantee that the *_SET_DATA listeners
  444.         // are always invoked before submit() takes place.
  445.         if (!$this->defaultDataSet) {
  446.             $this->setData($this->config->getData());
  447.         }
  449.         // Treat false as NULL to support binding false to checkboxes.
  450.         // Don't convert NULL to a string here in order to determine later
  451.         // whether an empty value has been submitted or whether no value has
  452.         // been submitted at all. This is important for processing checkboxes
  453.         // and radio buttons with empty values.
  454.         if (false === $submittedData) {
  455.             $submittedData = null;
  456.         } elseif (\is_scalar($submittedData)) {
  457.             $submittedData = (string) $submittedData;
  458.         } elseif ($this->config->getRequestHandler()->isFileUpload($submittedData)) {
  459.             if (!$this->config->getOption('allow_file_upload')) {
  460.                 $submittedData = null;
  461.                 $this->transformationFailure = new TransformationFailedException('Submitted data was expected to be text or number, file upload given.');
  462.             }
  463.         } elseif (\is_array($submittedData) && !$this->config->getCompound() && !$this->config->getOption('multiple', false)) {
  464.             $submittedData = null;
  465.             $this->transformationFailure = new TransformationFailedException('Submitted data was expected to be text or number, array given.');
  466.         }
  468.         $dispatcher = $this->config->getEventDispatcher();
  470.         $modelData = null;
  471.         $normData = null;
  472.         $viewData = null;
  474.         try {
  475.             if (null !== $this->transformationFailure) {
  476.                 throw $this->transformationFailure;
  477.             }
  479.             // Hook to change content of the data submitted by the browser
  480.             if ($dispatcher->hasListeners(FormEvents::PRE_SUBMIT)) {
  481.                 $event = new PreSubmitEvent($this, $submittedData);
  482.                 $dispatcher->dispatch($event, FormEvents::PRE_SUBMIT);
  483.                 $submittedData = $event->getData();
  484.             }
  486.             // Check whether the form is compound.
  487.             // This check is preferable over checking the number of children,
  488.             // since forms without children may also be compound.
  489.             // (think of empty collection forms)
  490.             if ($this->config->getCompound()) {
  491.                 if (!\is_array($submittedData ??= [])) {
  492.                     throw new TransformationFailedException('Compound forms expect an array or NULL on submission.');
  493.                 }
  495.                 foreach ($this->children as $name => $child) {
  496.                     $isSubmitted = \array_key_exists($name, $submittedData);
  498.                     if ($isSubmitted || $clearMissing) {
  499.                         $child->submit($isSubmitted ? $submittedData[$name] : null, $clearMissing);
  500.                         unset($submittedData[$name]);
  502.                         if (null !== $this->clickedButton) {
  503.                             continue;
  504.                         }
  506.                         if ($child instanceof ClickableInterface && $child->isClicked()) {
  507.                             $this->clickedButton = $child;
  509.                             continue;
  510.                         }
  512.                         if (method_exists($child, 'getClickedButton') && null !== $child->getClickedButton()) {
  513.                             $this->clickedButton = $child->getClickedButton();
  514.                         }
  515.                     }
  516.                 }
  518.                 $this->extraData = $submittedData;
  519.             }
  521.             // Forms that inherit their parents' data also are not processed,
  522.             // because then it would be too difficult to merge the changes in
  523.             // the child and the parent form. Instead, the parent form also takes
  524.             // changes in the grandchildren (i.e. children of the form that inherits
  525.             // its parent's data) into account.
  526.             // (see InheritDataAwareIterator below)
  527.             if (!$this->inheritData) {
  528.                 // If the form is compound, the view data is merged with the data
  529.                 // of the children using the data mapper.
  530.                 // If the form is not compound, the view data is assigned to the submitted data.
  531.                 $viewData = $this->config->getCompound() ? $this->viewData : $submittedData;
  533.                 if (FormUtil::isEmpty($viewData)) {
  534.                     $emptyData = $this->config->getEmptyData();
  536.                     if ($emptyData instanceof \Closure) {
  537.                         $emptyData = $emptyData($this, $viewData);
  538.                     }
  540.                     $viewData = $emptyData;
  541.                 }
  543.                 // Merge form data from children into existing view data
  544.                 // It is not necessary to invoke this method if the form has no children,
  545.                 // even if it is compound.
  546.                 if (\count($this->children) > 0) {
  547.                     // Use InheritDataAwareIterator to process children of
  548.                     // descendants that inherit this form's data.
  549.                     // These descendants will not be submitted normally (see the check
  550.                     // for $this->config->getInheritData() above)
  551.                     $this->config->getDataMapper()->mapFormsToData(
  552.                         new \RecursiveIteratorIterator(new InheritDataAwareIterator($this->children)),
  553.                         $viewData
  554.                     );
  555.                 }
  557.                 // Normalize data to unified representation
  558.                 $normData = $this->viewToNorm($viewData);
  560.                 // Hook to change content of the data in the normalized
  561.                 // representation
  562.                 if ($dispatcher->hasListeners(FormEvents::SUBMIT)) {
  563.                     $event = new SubmitEvent($this, $normData);
  564.                     $dispatcher->dispatch($event, FormEvents::SUBMIT);
  565.                     $normData = $event->getData();
  566.                 }
  568.                 // Synchronize representations - must not change the content!
  569.                 $modelData = $this->normToModel($normData);
  570.                 $viewData = $this->normToView($normData);
  571.             }
  572.         } catch (TransformationFailedException $e) {
  573.             $this->transformationFailure = $e;
  575.             // If $viewData was not yet set, set it to $submittedData so that
  576.             // the erroneous data is accessible on the form.
  577.             // Forms that inherit data never set any data, because the getters
  578.             // forward to the parent form's getters anyway.
  579.             if (null === $viewData && !$this->inheritData) {
  580.                 $viewData = $submittedData;
  581.             }
  582.         }
  584.         $this->submitted = true;
  585.         $this->modelData = $modelData;
  586.         $this->normData = $normData;
  587.         $this->viewData = $viewData;
  589.         if ($dispatcher->hasListeners(FormEvents::POST_SUBMIT)) {
  590.             $event = new PostSubmitEvent($this, $viewData);
  591.             $dispatcher->dispatch($event, FormEvents::POST_SUBMIT);
  592.         }
  594.         return $this;
  595.     }
  597.     public function addError(FormError $error): static
  598.     {
  599.         if (null === $error->getOrigin()) {
  600.             $error->setOrigin($this);
  601.         }
  603.         if ($this->parent && $this->config->getErrorBubbling()) {
  604.             $this->parent->addError($error);
  605.         } else {
  606.             $this->errors[] = $error;
  607.         }
  609.         return $this;
  610.     }
  612.     public function isSubmitted(): bool
  613.     {
  614.         return $this->submitted;
  615.     }
  617.     public function isSynchronized(): bool
  618.     {
  619.         return null === $this->transformationFailure;
  620.     }
  622.     public function getTransformationFailure(): ?Exception\TransformationFailedException
  623.     {
  624.         return $this->transformationFailure;
  625.     }
  627.     public function isEmpty(): bool
  628.     {
  629.         foreach ($this->children as $child) {
  630.             if (!$child->isEmpty()) {
  631.                 return false;
  632.             }
  633.         }
  635.         if (null !== $isEmptyCallback = $this->config->getIsEmptyCallback()) {
  636.             return $isEmptyCallback($this->modelData);
  637.         }
  639.         return FormUtil::isEmpty($this->modelData) ||
  640.             // arrays, countables
  641.             (is_countable($this->modelData) && 0 === \count($this->modelData)) ||
  642.             // traversables that are not countable
  643.             ($this->modelData instanceof \Traversable && 0 === iterator_count($this->modelData));
  644.     }
  646.     public function isValid(): bool
  647.     {
  648.         if (!$this->submitted) {
  649.             throw new LogicException('Cannot check if an unsubmitted form is valid. Call Form::isSubmitted() before Form::isValid().');
  650.         }
  652.         if ($this->isDisabled()) {
  653.             return true;
  654.         }
  656.         return 0 === \count($this->getErrors(true));
  657.     }
  659.     /**
  660.      * Returns the button that was used to submit the form.
  661.      */
  662.     public function getClickedButton(): FormInterface|ClickableInterface|null
  663.     {
  664.         if ($this->clickedButton) {
  665.             return $this->clickedButton;
  666.         }
  668.         return $this->parent && method_exists($this->parent, 'getClickedButton') ? $this->parent->getClickedButton() : null;
  669.     }
  671.     public function getErrors(bool $deep = false, bool $flatten = true): FormErrorIterator
  672.     {
  673.         $errors = $this->errors;
  675.         // Copy the errors of nested forms to the $errors array
  676.         if ($deep) {
  677.             foreach ($this as $child) {
  678.                 /** @var FormInterface $child */
  679.                 if ($child->isSubmitted() && $child->isValid()) {
  680.                     continue;
  681.                 }
  683.                 $iterator = $child->getErrors(true, $flatten);
  685.                 if (0 === \count($iterator)) {
  686.                     continue;
  687.                 }
  689.                 if ($flatten) {
  690.                     foreach ($iterator as $error) {
  691.                         $errors[] = $error;
  692.                     }
  693.                 } else {
  694.                     $errors[] = $iterator;
  695.                 }
  696.             }
  697.         }
  699.         return new FormErrorIterator($this, $errors);
  700.     }
  702.     public function clearErrors(bool $deep = false): static
  703.     {
  704.         $this->errors = [];
  706.         if ($deep) {
  707.             // Clear errors from children
  708.             foreach ($this as $child) {
  709.                 if ($child instanceof ClearableErrorsInterface) {
  710.                     $child->clearErrors(true);
  711.                 }
  712.             }
  713.         }
  715.         return $this;
  716.     }
  718.     public function all(): array
  719.     {
  720.         return iterator_to_array($this->children);
  721.     }
  723.     public function add(FormInterface|string $child, string $type = null, array $options = []): static
  724.     {
  725.         if ($this->submitted) {
  726.             throw new AlreadySubmittedException('You cannot add children to a submitted form.');
  727.         }
  729.         if (!$this->config->getCompound()) {
  730.             throw new LogicException('You cannot add children to a simple form. Maybe you should set the option "compound" to true?');
  731.         }
  733.         if (!$child instanceof FormInterface) {
  734.             if (!\is_string($child) && !\is_int($child)) {
  735.                 throw new UnexpectedTypeException($child, 'string or Symfony\Component\Form\FormInterface');
  736.             }
  738.             $child = (string) $child;
  740.             // Never initialize child forms automatically
  741.             $options['auto_initialize'] = false;
  743.             if (null === $type && null === $this->config->getDataClass()) {
  744.                 $type = TextType::class;
  745.             }
  747.             if (null === $type) {
  748.                 $child = $this->config->getFormFactory()->createForProperty($this->config->getDataClass(), $child, null, $options);
  749.             } else {
  750.                 $child = $this->config->getFormFactory()->createNamed($child, $type, null, $options);
  751.             }
  752.         } elseif ($child->getConfig()->getAutoInitialize()) {
  753.             throw new RuntimeException(sprintf('Automatic initialization is only supported on root forms. You should set the "auto_initialize" option to false on the field "%s".', $child->getName()));
  754.         }
  756.         $this->children[$child->getName()] = $child;
  758.         $child->setParent($this);
  760.         // If setData() is currently being called, there is no need to call
  761.         // mapDataToForms() here, as mapDataToForms() is called at the end
  762.         // of setData() anyway. Not doing this check leads to an endless
  763.         // recursion when initializing the form lazily and an event listener
  764.         // (such as ResizeFormListener) adds fields depending on the data:
  765.         //
  766.         //  * setData() is called, the form is not initialized yet
  767.         //  * add() is called by the listener (setData() is not complete, so
  768.         //    the form is still not initialized)
  769.         //  * getViewData() is called
  770.         //  * setData() is called since the form is not initialized yet
  771.         //  * ... endless recursion ...
  772.         //
  773.         // Also skip data mapping if setData() has not been called yet.
  774.         // setData() will be called upon form initialization and data mapping
  775.         // will take place by then.
  776.         if (!$this->lockSetData && $this->defaultDataSet && !$this->inheritData) {
  777.             $viewData = $this->getViewData();
  778.             $this->config->getDataMapper()->mapDataToForms(
  779.                 $viewData,
  780.                 new \RecursiveIteratorIterator(new InheritDataAwareIterator(new \ArrayIterator([$child->getName() => $child])))
  781.             );
  782.         }
  784.         return $this;
  785.     }
  787.     public function remove(string $name): static
  788.     {
  789.         if ($this->submitted) {
  790.             throw new AlreadySubmittedException('You cannot remove children from a submitted form.');
  791.         }
  793.         if (isset($this->children[$name])) {
  794.             if (!$this->children[$name]->isSubmitted()) {
  795.                 $this->children[$name]->setParent(null);
  796.             }
  798.             unset($this->children[$name]);
  799.         }
  801.         return $this;
  802.     }
  804.     public function has(string $name): bool
  805.     {
  806.         return isset($this->children[$name]);
  807.     }
  809.     public function get(string $name): FormInterface
  810.     {
  811.         if (isset($this->children[$name])) {
  812.             return $this->children[$name];
  813.         }
  815.         throw new OutOfBoundsException(sprintf('Child "%s" does not exist.', $name));
  816.     }
  818.     /**
  819.      * Returns whether a child with the given name exists (implements the \ArrayAccess interface).
  820.      *
  821.      * @param string $name The name of the child
  822.      */
  823.     public function offsetExists(mixed $name): bool
  824.     {
  825.         return $this->has($name);
  826.     }
  828.     /**
  829.      * Returns the child with the given name (implements the \ArrayAccess interface).
  830.      *
  831.      * @param string $name The name of the child
  832.      *
  833.      * @throws OutOfBoundsException if the named child does not exist
  834.      */
  835.     public function offsetGet(mixed $name): FormInterface
  836.     {
  837.         return $this->get($name);
  838.     }
  840.     /**
  841.      * Adds a child to the form (implements the \ArrayAccess interface).
  842.      *
  843.      * @param string        $name  Ignored. The name of the child is used
  844.      * @param FormInterface $child The child to be added
  845.      *
  846.      * @throws AlreadySubmittedException if the form has already been submitted
  847.      * @throws LogicException            when trying to add a child to a non-compound form
  848.      *
  849.      * @see self::add()
  850.      */
  851.     public function offsetSet(mixed $name, mixed $child): void
  852.     {
  853.         $this->add($child);
  854.     }
  856.     /**
  857.      * Removes the child with the given name from the form (implements the \ArrayAccess interface).
  858.      *
  859.      * @param string $name The name of the child to remove
  860.      *
  861.      * @throws AlreadySubmittedException if the form has already been submitted
  862.      */
  863.     public function offsetUnset(mixed $name): void
  864.     {
  865.         $this->remove($name);
  866.     }
  868.     /**
  869.      * Returns the iterator for this group.
  870.      *
  871.      * @return \Traversable<string, FormInterface>
  872.      */
  873.     public function getIterator(): \Traversable
  874.     {
  875.         return $this->children;
  876.     }
  878.     /**
  879.      * Returns the number of form children (implements the \Countable interface).
  880.      */
  881.     public function count(): int
  882.     {
  883.         return \count($this->children);
  884.     }
  886.     public function createView(FormView $parent = null): FormView
  887.     {
  888.         if (null === $parent && $this->parent) {
  889.             $parent = $this->parent->createView();
  890.         }
  892.         $type = $this->config->getType();
  893.         $options = $this->config->getOptions();
  895.         // The methods createView(), buildView() and finishView() are called
  896.         // explicitly here in order to be able to override either of them
  897.         // in a custom resolved form type.
  898.         $view = $type->createView($this, $parent);
  900.         $type->buildView($view, $this, $options);
  902.         foreach ($this->children as $name => $child) {
  903.             $view->children[$name] = $child->createView($view);
  904.         }
  906.         $this->sort($view->children);
  908.         $type->finishView($view, $this, $options);
  910.         return $view;
  911.     }
  913.     /**
  914.      * Sorts view fields based on their priority value.
  915.      */
  916.     private function sort(array &$children): void
  917.     {
  918.         $c = [];
  919.         $i = 0;
  920.         $needsSorting = false;
  921.         foreach ($children as $name => $child) {
  922.             $c[$name] = ['p' => $child->vars['priority'] ?? 0, 'i' => $i++];
  924.             if (0 !== $c[$name]['p']) {
  925.                 $needsSorting = true;
  926.             }
  927.         }
  929.         if (!$needsSorting) {
  930.             return;
  931.         }
  933.         uksort($children, static function ($a, $b) use ($c): int {
  934.             return [$c[$b]['p'], $c[$a]['i']] <=> [$c[$a]['p'], $c[$b]['i']];
  935.         });
  936.     }
  938.     /**
  939.      * Normalizes the underlying data if a model transformer is set.
  940.      *
  941.      * @throws TransformationFailedException If the underlying data cannot be transformed to "normalized" format
  942.      */
  943.     private function modelToNorm(mixed $value): mixed
  944.     {
  945.         try {
  946.             foreach ($this->config->getModelTransformers() as $transformer) {
  947.                 $value = $transformer->transform($value);
  948.             }
  949.         } catch (TransformationFailedException $exception) {
  950.             throw new TransformationFailedException(sprintf('Unable to transform data for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  951.         }
  953.         return $value;
  954.     }
  956.     /**
  957.      * Reverse transforms a value if a model transformer is set.
  958.      *
  959.      * @throws TransformationFailedException If the value cannot be transformed to "model" format
  960.      */
  961.     private function normToModel(mixed $value): mixed
  962.     {
  963.         try {
  964.             $transformers = $this->config->getModelTransformers();
  966.             for ($i = \count($transformers) - 1; $i >= 0; --$i) {
  967.                 $value = $transformers[$i]->reverseTransform($value);
  968.             }
  969.         } catch (TransformationFailedException $exception) {
  970.             throw new TransformationFailedException(sprintf('Unable to reverse value for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  971.         }
  973.         return $value;
  974.     }
  976.     /**
  977.      * Transforms the value if a view transformer is set.
  978.      *
  979.      * @throws TransformationFailedException If the normalized value cannot be transformed to "view" format
  980.      */
  981.     private function normToView(mixed $value): mixed
  982.     {
  983.         // Scalar values should  be converted to strings to
  984.         // facilitate differentiation between empty ("") and zero (0).
  985.         // Only do this for simple forms, as the resulting value in
  986.         // compound forms is passed to the data mapper and thus should
  987.         // not be converted to a string before.
  988.         if (!($transformers = $this->config->getViewTransformers()) && !$this->config->getCompound()) {
  989.             return null === $value || \is_scalar($value) ? (string) $value : $value;
  990.         }
  992.         try {
  993.             foreach ($transformers as $transformer) {
  994.                 $value = $transformer->transform($value);
  995.             }
  996.         } catch (TransformationFailedException $exception) {
  997.             throw new TransformationFailedException(sprintf('Unable to transform value for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  998.         }
  1000.         return $value;
  1001.     }
  1003.     /**
  1004.      * Reverse transforms a value if a view transformer is set.
  1005.      *
  1006.      * @throws TransformationFailedException If the submitted value cannot be transformed to "normalized" format
  1007.      */
  1008.     private function viewToNorm(mixed $value): mixed
  1009.     {
  1010.         if (!$transformers = $this->config->getViewTransformers()) {
  1011.             return '' === $value ? null : $value;
  1012.         }
  1014.         try {
  1015.             for ($i = \count($transformers) - 1; $i >= 0; --$i) {
  1016.                 $value = $transformers[$i]->reverseTransform($value);
  1017.             }
  1018.         } catch (TransformationFailedException $exception) {
  1019.             throw new TransformationFailedException(sprintf('Unable to reverse value for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  1020.         }
  1022.         return $value;
  1023.     }
  1024. }