vendor/symfony/form/Form.php line 72

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\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.     /**
  75.      * @var FormConfigInterface
  76.      */
  77.     private $config;
  79.     /**
  80.      * @var FormInterface|null
  81.      */
  82.     private $parent;
  84.     /**
  85.      * A map of FormInterface instances.
  86.      *
  87.      * @var OrderedHashMap<string, FormInterface>
  88.      */
  89.     private $children;
  91.     /**
  92.      * @var FormError[]
  93.      */
  94.     private $errors = [];
  96.     /**
  97.      * @var bool
  98.      */
  99.     private $submitted = false;
  101.     /**
  102.      * The button that was used to submit the form.
  103.      *
  104.      * @var FormInterface|ClickableInterface|null
  105.      */
  106.     private $clickedButton;
  108.     /**
  109.      * @var mixed
  110.      */
  111.     private $modelData;
  113.     /**
  114.      * @var mixed
  115.      */
  116.     private $normData;
  118.     /**
  119.      * @var mixed
  120.      */
  121.     private $viewData;
  123.     /**
  124.      * The submitted values that don't belong to any children.
  125.      *
  126.      * @var array
  127.      */
  128.     private $extraData = [];
  130.     /**
  131.      * The transformation failure generated during submission, if any.
  132.      *
  133.      * @var TransformationFailedException|null
  134.      */
  135.     private $transformationFailure;
  137.     /**
  138.      * Whether the form's data has been initialized.
  139.      *
  140.      * When the data is initialized with its default value, that default value
  141.      * is passed through the transformer chain in order to synchronize the
  142.      * model, normalized and view format for the first time. This is done
  143.      * lazily in order to save performance when {@link setData()} is called
  144.      * manually, making the initialization with the configured default value
  145.      * superfluous.
  146.      *
  147.      * @var bool
  148.      */
  149.     private $defaultDataSet = false;
  151.     /**
  152.      * Whether setData() is currently being called.
  153.      *
  154.      * @var bool
  155.      */
  156.     private $lockSetData = false;
  158.     /**
  159.      * @var string
  160.      */
  161.     private $name = '';
  163.     /**
  164.      * Whether the form inherits its underlying data from its parent.
  165.      *
  166.      * @var bool
  167.      */
  168.     private $inheritData;
  170.     /**
  171.      * @var PropertyPathInterface|null
  172.      */
  173.     private $propertyPath;
  175.     /**
  176.      * @throws LogicException if a data mapper is not provided for a compound form
  177.      */
  178.     public function __construct(FormConfigInterface $config)
  179.     {
  180.         // Compound forms always need a data mapper, otherwise calls to
  181.         // `setData` and `add` will not lead to the correct population of
  182.         // the child forms.
  183.         if ($config->getCompound() && !$config->getDataMapper()) {
  184.             throw new LogicException('Compound forms need a data mapper.');
  185.         }
  187.         // If the form inherits the data from its parent, it is not necessary
  188.         // to call setData() with the default data.
  189.         if ($this->inheritData = $config->getInheritData()) {
  190.             $this->defaultDataSet = true;
  191.         }
  193.         $this->config = $config;
  194.         $this->children = new OrderedHashMap();
  195.         $this->name = $config->getName();
  196.     }
  198.     public function __clone()
  199.     {
  200.         $this->children = clone $this->children;
  202.         foreach ($this->children as $key => $child) {
  203.             $this->children[$key] = clone $child;
  204.         }
  205.     }
  207.     /**
  208.      * {@inheritdoc}
  209.      */
  210.     public function getConfig()
  211.     {
  212.         return $this->config;
  213.     }
  215.     /**
  216.      * {@inheritdoc}
  217.      */
  218.     public function getName()
  219.     {
  220.         return $this->name;
  221.     }
  223.     /**
  224.      * {@inheritdoc}
  225.      */
  226.     public function getPropertyPath()
  227.     {
  228.         if ($this->propertyPath || $this->propertyPath = $this->config->getPropertyPath()) {
  229.             return $this->propertyPath;
  230.         }
  232.         if ('' === $this->name) {
  233.             return null;
  234.         }
  236.         $parent = $this->parent;
  238.         while ($parent && $parent->getConfig()->getInheritData()) {
  239.             $parent = $parent->getParent();
  240.         }
  242.         if ($parent && null === $parent->getConfig()->getDataClass()) {
  243.             $this->propertyPath = new PropertyPath('['.$this->name.']');
  244.         } else {
  245.             $this->propertyPath = new PropertyPath($this->name);
  246.         }
  248.         return $this->propertyPath;
  249.     }
  251.     /**
  252.      * {@inheritdoc}
  253.      */
  254.     public function isRequired()
  255.     {
  256.         if (null === $this->parent || $this->parent->isRequired()) {
  257.             return $this->config->getRequired();
  258.         }
  260.         return false;
  261.     }
  263.     /**
  264.      * {@inheritdoc}
  265.      */
  266.     public function isDisabled()
  267.     {
  268.         if (null === $this->parent || !$this->parent->isDisabled()) {
  269.             return $this->config->getDisabled();
  270.         }
  272.         return true;
  273.     }
  275.     /**
  276.      * {@inheritdoc}
  277.      */
  278.     public function setParent(FormInterface $parent = null)
  279.     {
  280.         if ($this->submitted) {
  281.             throw new AlreadySubmittedException('You cannot set the parent of a submitted form.');
  282.         }
  284.         if (null !== $parent && '' === $this->name) {
  285.             throw new LogicException('A form with an empty name cannot have a parent form.');
  286.         }
  288.         $this->parent = $parent;
  290.         return $this;
  291.     }
  293.     /**
  294.      * {@inheritdoc}
  295.      */
  296.     public function getParent()
  297.     {
  298.         return $this->parent;
  299.     }
  301.     /**
  302.      * {@inheritdoc}
  303.      */
  304.     public function getRoot()
  305.     {
  306.         return $this->parent ? $this->parent->getRoot() : $this;
  307.     }
  309.     /**
  310.      * {@inheritdoc}
  311.      */
  312.     public function isRoot()
  313.     {
  314.         return null === $this->parent;
  315.     }
  317.     /**
  318.      * {@inheritdoc}
  319.      */
  320.     public function setData($modelData)
  321.     {
  322.         // If the form is submitted while disabled, it is set to submitted, but the data is not
  323.         // changed. In such cases (i.e. when the form is not initialized yet) don't
  324.         // abort this method.
  325.         if ($this->submitted && $this->defaultDataSet) {
  326.             throw new AlreadySubmittedException('You cannot change the data of a submitted form.');
  327.         }
  329.         // If the form inherits its parent's data, disallow data setting to
  330.         // prevent merge conflicts
  331.         if ($this->inheritData) {
  332.             throw new RuntimeException('You cannot change the data of a form inheriting its parent data.');
  333.         }
  335.         // Don't allow modifications of the configured data if the data is locked
  336.         if ($this->config->getDataLocked() && $modelData !== $this->config->getData()) {
  337.             return $this;
  338.         }
  340.         if (\is_object($modelData) && !$this->config->getByReference()) {
  341.             $modelData = clone $modelData;
  342.         }
  344.         if ($this->lockSetData) {
  345.             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.');
  346.         }
  348.         $this->lockSetData = true;
  349.         $dispatcher = $this->config->getEventDispatcher();
  351.         // Hook to change content of the model data before transformation and mapping children
  352.         if ($dispatcher->hasListeners(FormEvents::PRE_SET_DATA)) {
  353.             $event = new PreSetDataEvent($this, $modelData);
  354.             $dispatcher->dispatch($event, FormEvents::PRE_SET_DATA);
  355.             $modelData = $event->getData();
  356.         }
  358.         // Treat data as strings unless a transformer exists
  359.         if (is_scalar($modelData) && !$this->config->getViewTransformers() && !$this->config->getModelTransformers()) {
  360.             $modelData = (string) $modelData;
  361.         }
  363.         // Synchronize representations - must not change the content!
  364.         // Transformation exceptions are not caught on initialization
  365.         $normData = $this->modelToNorm($modelData);
  366.         $viewData = $this->normToView($normData);
  368.         // Validate if view data matches data class (unless empty)
  369.         if (!FormUtil::isEmpty($viewData)) {
  370.             $dataClass = $this->config->getDataClass();
  372.             if (null !== $dataClass && !$viewData instanceof $dataClass) {
  373.                 $actualType = get_debug_type($viewData);
  375.                 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.'".');
  376.             }
  377.         }
  379.         $this->modelData = $modelData;
  380.         $this->normData = $normData;
  381.         $this->viewData = $viewData;
  382.         $this->defaultDataSet = true;
  383.         $this->lockSetData = false;
  385.         // Compound forms don't need to invoke this method if they don't have children
  386.         if (\count($this->children) > 0) {
  387.             // Update child forms from the data (unless their config data is locked)
  388.             $this->config->getDataMapper()->mapDataToForms($viewData, new \RecursiveIteratorIterator(new InheritDataAwareIterator($this->children)));
  389.         }
  391.         if ($dispatcher->hasListeners(FormEvents::POST_SET_DATA)) {
  392.             $event = new PostSetDataEvent($this, $modelData);
  393.             $dispatcher->dispatch($event, FormEvents::POST_SET_DATA);
  394.         }
  396.         return $this;
  397.     }
  399.     /**
  400.      * {@inheritdoc}
  401.      */
  402.     public function getData()
  403.     {
  404.         if ($this->inheritData) {
  405.             if (!$this->parent) {
  406.                 throw new RuntimeException('The form is configured to inherit its parent\'s data, but does not have a parent.');
  407.             }
  409.             return $this->parent->getData();
  410.         }
  412.         if (!$this->defaultDataSet) {
  413.             if ($this->lockSetData) {
  414.                 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.');
  415.             }
  417.             $this->setData($this->config->getData());
  418.         }
  420.         return $this->modelData;
  421.     }
  423.     /**
  424.      * {@inheritdoc}
  425.      */
  426.     public function getNormData()
  427.     {
  428.         if ($this->inheritData) {
  429.             if (!$this->parent) {
  430.                 throw new RuntimeException('The form is configured to inherit its parent\'s data, but does not have a parent.');
  431.             }
  433.             return $this->parent->getNormData();
  434.         }
  436.         if (!$this->defaultDataSet) {
  437.             if ($this->lockSetData) {
  438.                 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.');
  439.             }
  441.             $this->setData($this->config->getData());
  442.         }
  444.         return $this->normData;
  445.     }
  447.     /**
  448.      * {@inheritdoc}
  449.      */
  450.     public function getViewData()
  451.     {
  452.         if ($this->inheritData) {
  453.             if (!$this->parent) {
  454.                 throw new RuntimeException('The form is configured to inherit its parent\'s data, but does not have a parent.');
  455.             }
  457.             return $this->parent->getViewData();
  458.         }
  460.         if (!$this->defaultDataSet) {
  461.             if ($this->lockSetData) {
  462.                 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.');
  463.             }
  465.             $this->setData($this->config->getData());
  466.         }
  468.         return $this->viewData;
  469.     }
  471.     /**
  472.      * {@inheritdoc}
  473.      */
  474.     public function getExtraData()
  475.     {
  476.         return $this->extraData;
  477.     }
  479.     /**
  480.      * {@inheritdoc}
  481.      */
  482.     public function initialize()
  483.     {
  484.         if (null !== $this->parent) {
  485.             throw new RuntimeException('Only root forms should be initialized.');
  486.         }
  488.         // Guarantee that the *_SET_DATA events have been triggered once the
  489.         // form is initialized. This makes sure that dynamically added or
  490.         // removed fields are already visible after initialization.
  491.         if (!$this->defaultDataSet) {
  492.             $this->setData($this->config->getData());
  493.         }
  495.         return $this;
  496.     }
  498.     /**
  499.      * {@inheritdoc}
  500.      */
  501.     public function handleRequest($request = null)
  502.     {
  503.         $this->config->getRequestHandler()->handleRequest($this, $request);
  505.         return $this;
  506.     }
  508.     /**
  509.      * {@inheritdoc}
  510.      */
  511.     public function submit($submittedData, bool $clearMissing = true)
  512.     {
  513.         if ($this->submitted) {
  514.             throw new AlreadySubmittedException('A form can only be submitted once.');
  515.         }
  517.         // Initialize errors in the very beginning so we're sure
  518.         // they are collectable during submission only
  519.         $this->errors = [];
  521.         // Obviously, a disabled form should not change its data upon submission.
  522.         if ($this->isDisabled()) {
  523.             $this->submitted = true;
  525.             return $this;
  526.         }
  528.         // The data must be initialized if it was not initialized yet.
  529.         // This is necessary to guarantee that the *_SET_DATA listeners
  530.         // are always invoked before submit() takes place.
  531.         if (!$this->defaultDataSet) {
  532.             $this->setData($this->config->getData());
  533.         }
  535.         // Treat false as NULL to support binding false to checkboxes.
  536.         // Don't convert NULL to a string here in order to determine later
  537.         // whether an empty value has been submitted or whether no value has
  538.         // been submitted at all. This is important for processing checkboxes
  539.         // and radio buttons with empty values.
  540.         if (false === $submittedData) {
  541.             $submittedData = null;
  542.         } elseif (is_scalar($submittedData)) {
  543.             $submittedData = (string) $submittedData;
  544.         } elseif ($this->config->getRequestHandler()->isFileUpload($submittedData)) {
  545.             if (!$this->config->getOption('allow_file_upload')) {
  546.                 $submittedData = null;
  547.                 $this->transformationFailure = new TransformationFailedException('Submitted data was expected to be text or number, file upload given.');
  548.             }
  549.         } elseif (\is_array($submittedData) && !$this->config->getCompound() && !$this->config->getOption('multiple', false)) {
  550.             $submittedData = null;
  551.             $this->transformationFailure = new TransformationFailedException('Submitted data was expected to be text or number, array given.');
  552.         }
  554.         $dispatcher = $this->config->getEventDispatcher();
  556.         $modelData = null;
  557.         $normData = null;
  558.         $viewData = null;
  560.         try {
  561.             if (null !== $this->transformationFailure) {
  562.                 throw $this->transformationFailure;
  563.             }
  565.             // Hook to change content of the data submitted by the browser
  566.             if ($dispatcher->hasListeners(FormEvents::PRE_SUBMIT)) {
  567.                 $event = new PreSubmitEvent($this, $submittedData);
  568.                 $dispatcher->dispatch($event, FormEvents::PRE_SUBMIT);
  569.                 $submittedData = $event->getData();
  570.             }
  572.             // Check whether the form is compound.
  573.             // This check is preferable over checking the number of children,
  574.             // since forms without children may also be compound.
  575.             // (think of empty collection forms)
  576.             if ($this->config->getCompound()) {
  577.                 if (null === $submittedData) {
  578.                     $submittedData = [];
  579.                 }
  581.                 if (!\is_array($submittedData)) {
  582.                     throw new TransformationFailedException('Compound forms expect an array or NULL on submission.');
  583.                 }
  585.                 foreach ($this->children as $name => $child) {
  586.                     $isSubmitted = \array_key_exists($name, $submittedData);
  588.                     if ($isSubmitted || $clearMissing) {
  589.                         $child->submit($isSubmitted ? $submittedData[$name] : null, $clearMissing);
  590.                         unset($submittedData[$name]);
  592.                         if (null !== $this->clickedButton) {
  593.                             continue;
  594.                         }
  596.                         if ($child instanceof ClickableInterface && $child->isClicked()) {
  597.                             $this->clickedButton = $child;
  599.                             continue;
  600.                         }
  602.                         if (method_exists($child, 'getClickedButton') && null !== $child->getClickedButton()) {
  603.                             $this->clickedButton = $child->getClickedButton();
  604.                         }
  605.                     }
  606.                 }
  608.                 $this->extraData = $submittedData;
  609.             }
  611.             // Forms that inherit their parents' data also are not processed,
  612.             // because then it would be too difficult to merge the changes in
  613.             // the child and the parent form. Instead, the parent form also takes
  614.             // changes in the grandchildren (i.e. children of the form that inherits
  615.             // its parent's data) into account.
  616.             // (see InheritDataAwareIterator below)
  617.             if (!$this->inheritData) {
  618.                 // If the form is compound, the view data is merged with the data
  619.                 // of the children using the data mapper.
  620.                 // If the form is not compound, the view data is assigned to the submitted data.
  621.                 $viewData = $this->config->getCompound() ? $this->viewData : $submittedData;
  623.                 if (FormUtil::isEmpty($viewData)) {
  624.                     $emptyData = $this->config->getEmptyData();
  626.                     if ($emptyData instanceof \Closure) {
  627.                         $emptyData = $emptyData($this, $viewData);
  628.                     }
  630.                     $viewData = $emptyData;
  631.                 }
  633.                 // Merge form data from children into existing view data
  634.                 // It is not necessary to invoke this method if the form has no children,
  635.                 // even if it is compound.
  636.                 if (\count($this->children) > 0) {
  637.                     // Use InheritDataAwareIterator to process children of
  638.                     // descendants that inherit this form's data.
  639.                     // These descendants will not be submitted normally (see the check
  640.                     // for $this->config->getInheritData() above)
  641.                     $this->config->getDataMapper()->mapFormsToData(
  642.                         new \RecursiveIteratorIterator(new InheritDataAwareIterator($this->children)),
  643.                         $viewData
  644.                     );
  645.                 }
  647.                 // Normalize data to unified representation
  648.                 $normData = $this->viewToNorm($viewData);
  650.                 // Hook to change content of the data in the normalized
  651.                 // representation
  652.                 if ($dispatcher->hasListeners(FormEvents::SUBMIT)) {
  653.                     $event = new SubmitEvent($this, $normData);
  654.                     $dispatcher->dispatch($event, FormEvents::SUBMIT);
  655.                     $normData = $event->getData();
  656.                 }
  658.                 // Synchronize representations - must not change the content!
  659.                 $modelData = $this->normToModel($normData);
  660.                 $viewData = $this->normToView($normData);
  661.             }
  662.         } catch (TransformationFailedException $e) {
  663.             $this->transformationFailure = $e;
  665.             // If $viewData was not yet set, set it to $submittedData so that
  666.             // the erroneous data is accessible on the form.
  667.             // Forms that inherit data never set any data, because the getters
  668.             // forward to the parent form's getters anyway.
  669.             if (null === $viewData && !$this->inheritData) {
  670.                 $viewData = $submittedData;
  671.             }
  672.         }
  674.         $this->submitted = true;
  675.         $this->modelData = $modelData;
  676.         $this->normData = $normData;
  677.         $this->viewData = $viewData;
  679.         if ($dispatcher->hasListeners(FormEvents::POST_SUBMIT)) {
  680.             $event = new PostSubmitEvent($this, $viewData);
  681.             $dispatcher->dispatch($event, FormEvents::POST_SUBMIT);
  682.         }
  684.         return $this;
  685.     }
  687.     /**
  688.      * {@inheritdoc}
  689.      */
  690.     public function addError(FormError $error)
  691.     {
  692.         if (null === $error->getOrigin()) {
  693.             $error->setOrigin($this);
  694.         }
  696.         if ($this->parent && $this->config->getErrorBubbling()) {
  697.             $this->parent->addError($error);
  698.         } else {
  699.             $this->errors[] = $error;
  700.         }
  702.         return $this;
  703.     }
  705.     /**
  706.      * {@inheritdoc}
  707.      */
  708.     public function isSubmitted()
  709.     {
  710.         return $this->submitted;
  711.     }
  713.     /**
  714.      * {@inheritdoc}
  715.      */
  716.     public function isSynchronized()
  717.     {
  718.         return null === $this->transformationFailure;
  719.     }
  721.     /**
  722.      * {@inheritdoc}
  723.      */
  724.     public function getTransformationFailure()
  725.     {
  726.         return $this->transformationFailure;
  727.     }
  729.     /**
  730.      * {@inheritdoc}
  731.      */
  732.     public function isEmpty()
  733.     {
  734.         foreach ($this->children as $child) {
  735.             if (!$child->isEmpty()) {
  736.                 return false;
  737.             }
  738.         }
  740.         if (!method_exists($this->config, 'getIsEmptyCallback')) {
  741.             trigger_deprecation('symfony/form', '5.1', 'Not implementing the "%s::getIsEmptyCallback()" method in "%s" is deprecated.', FormConfigInterface::class, \get_class($this->config));
  743.             $isEmptyCallback = null;
  744.         } else {
  745.             $isEmptyCallback = $this->config->getIsEmptyCallback();
  746.         }
  748.         if (null !== $isEmptyCallback) {
  749.             return $isEmptyCallback($this->modelData);
  750.         }
  752.         return FormUtil::isEmpty($this->modelData) ||
  753.             // arrays, countables
  754.             ((\is_array($this->modelData) || $this->modelData instanceof \Countable) && 0 === \count($this->modelData)) ||
  755.             // traversables that are not countable
  756.             ($this->modelData instanceof \Traversable && 0 === iterator_count($this->modelData));
  757.     }
  759.     /**
  760.      * {@inheritdoc}
  761.      */
  762.     public function isValid()
  763.     {
  764.         if (!$this->submitted) {
  765.             throw new LogicException('Cannot check if an unsubmitted form is valid. Call Form::isSubmitted() before Form::isValid().');
  766.         }
  768.         if ($this->isDisabled()) {
  769.             return true;
  770.         }
  772.         return 0 === \count($this->getErrors(true));
  773.     }
  775.     /**
  776.      * Returns the button that was used to submit the form.
  777.      *
  778.      * @return FormInterface|ClickableInterface|null
  779.      */
  780.     public function getClickedButton()
  781.     {
  782.         if ($this->clickedButton) {
  783.             return $this->clickedButton;
  784.         }
  786.         return $this->parent && method_exists($this->parent, 'getClickedButton') ? $this->parent->getClickedButton() : null;
  787.     }
  789.     /**
  790.      * {@inheritdoc}
  791.      */
  792.     public function getErrors(bool $deep = false, bool $flatten = true)
  793.     {
  794.         $errors = $this->errors;
  796.         // Copy the errors of nested forms to the $errors array
  797.         if ($deep) {
  798.             foreach ($this as $child) {
  799.                 /** @var FormInterface $child */
  800.                 if ($child->isSubmitted() && $child->isValid()) {
  801.                     continue;
  802.                 }
  804.                 $iterator = $child->getErrors(true, $flatten);
  806.                 if (0 === \count($iterator)) {
  807.                     continue;
  808.                 }
  810.                 if ($flatten) {
  811.                     foreach ($iterator as $error) {
  812.                         $errors[] = $error;
  813.                     }
  814.                 } else {
  815.                     $errors[] = $iterator;
  816.                 }
  817.             }
  818.         }
  820.         return new FormErrorIterator($this, $errors);
  821.     }
  823.     /**
  824.      * {@inheritdoc}
  825.      */
  826.     public function clearErrors(bool $deep = false): self
  827.     {
  828.         $this->errors = [];
  830.         if ($deep) {
  831.             // Clear errors from children
  832.             foreach ($this as $child) {
  833.                 if ($child instanceof ClearableErrorsInterface) {
  834.                     $child->clearErrors(true);
  835.                 }
  836.             }
  837.         }
  839.         return $this;
  840.     }
  842.     /**
  843.      * {@inheritdoc}
  844.      */
  845.     public function all()
  846.     {
  847.         return iterator_to_array($this->children);
  848.     }
  850.     /**
  851.      * {@inheritdoc}
  852.      */
  853.     public function add($child, string $type = null, array $options = [])
  854.     {
  855.         if ($this->submitted) {
  856.             throw new AlreadySubmittedException('You cannot add children to a submitted form.');
  857.         }
  859.         if (!$this->config->getCompound()) {
  860.             throw new LogicException('You cannot add children to a simple form. Maybe you should set the option "compound" to true?');
  861.         }
  863.         if (!$child instanceof FormInterface) {
  864.             if (!\is_string($child) && !\is_int($child)) {
  865.                 throw new UnexpectedTypeException($child, 'string or Symfony\Component\Form\FormInterface');
  866.             }
  868.             $child = (string) $child;
  870.             if (null !== $type && !\is_string($type)) {
  871.                 throw new UnexpectedTypeException($type, 'string or null');
  872.             }
  874.             // Never initialize child forms automatically
  875.             $options['auto_initialize'] = false;
  877.             if (null === $type && null === $this->config->getDataClass()) {
  878.                 $type = TextType::class;
  879.             }
  881.             if (null === $type) {
  882.                 $child = $this->config->getFormFactory()->createForProperty($this->config->getDataClass(), $child, null, $options);
  883.             } else {
  884.                 $child = $this->config->getFormFactory()->createNamed($child, $type, null, $options);
  885.             }
  886.         } elseif ($child->getConfig()->getAutoInitialize()) {
  887.             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()));
  888.         }
  890.         $this->children[$child->getName()] = $child;
  892.         $child->setParent($this);
  894.         // If setData() is currently being called, there is no need to call
  895.         // mapDataToForms() here, as mapDataToForms() is called at the end
  896.         // of setData() anyway. Not doing this check leads to an endless
  897.         // recursion when initializing the form lazily and an event listener
  898.         // (such as ResizeFormListener) adds fields depending on the data:
  899.         //
  900.         //  * setData() is called, the form is not initialized yet
  901.         //  * add() is called by the listener (setData() is not complete, so
  902.         //    the form is still not initialized)
  903.         //  * getViewData() is called
  904.         //  * setData() is called since the form is not initialized yet
  905.         //  * ... endless recursion ...
  906.         //
  907.         // Also skip data mapping if setData() has not been called yet.
  908.         // setData() will be called upon form initialization and data mapping
  909.         // will take place by then.
  910.         if (!$this->lockSetData && $this->defaultDataSet && !$this->inheritData) {
  911.             $viewData = $this->getViewData();
  912.             $this->config->getDataMapper()->mapDataToForms(
  913.                 $viewData,
  914.                 new \RecursiveIteratorIterator(new InheritDataAwareIterator(new \ArrayIterator([$child->getName() => $child])))
  915.             );
  916.         }
  918.         return $this;
  919.     }
  921.     /**
  922.      * {@inheritdoc}
  923.      */
  924.     public function remove(string $name)
  925.     {
  926.         if ($this->submitted) {
  927.             throw new AlreadySubmittedException('You cannot remove children from a submitted form.');
  928.         }
  930.         if (isset($this->children[$name])) {
  931.             if (!$this->children[$name]->isSubmitted()) {
  932.                 $this->children[$name]->setParent(null);
  933.             }
  935.             unset($this->children[$name]);
  936.         }
  938.         return $this;
  939.     }
  941.     /**
  942.      * {@inheritdoc}
  943.      */
  944.     public function has(string $name)
  945.     {
  946.         return isset($this->children[$name]);
  947.     }
  949.     /**
  950.      * {@inheritdoc}
  951.      */
  952.     public function get(string $name)
  953.     {
  954.         if (isset($this->children[$name])) {
  955.             return $this->children[$name];
  956.         }
  958.         throw new OutOfBoundsException(sprintf('Child "%s" does not exist.', $name));
  959.     }
  961.     /**
  962.      * Returns whether a child with the given name exists (implements the \ArrayAccess interface).
  963.      *
  964.      * @param string $name The name of the child
  965.      *
  966.      * @return bool
  967.      */
  968.     #[\ReturnTypeWillChange]
  969.     public function offsetExists($name)
  970.     {
  971.         return $this->has($name);
  972.     }
  974.     /**
  975.      * Returns the child with the given name (implements the \ArrayAccess interface).
  976.      *
  977.      * @param string $name The name of the child
  978.      *
  979.      * @return FormInterface
  980.      *
  981.      * @throws OutOfBoundsException if the named child does not exist
  982.      */
  983.     #[\ReturnTypeWillChange]
  984.     public function offsetGet($name)
  985.     {
  986.         return $this->get($name);
  987.     }
  989.     /**
  990.      * Adds a child to the form (implements the \ArrayAccess interface).
  991.      *
  992.      * @param string        $name  Ignored. The name of the child is used
  993.      * @param FormInterface $child The child to be added
  994.      *
  995.      * @return void
  996.      *
  997.      * @throws AlreadySubmittedException if the form has already been submitted
  998.      * @throws LogicException            when trying to add a child to a non-compound form
  999.      *
  1000.      * @see self::add()
  1001.      */
  1002.     #[\ReturnTypeWillChange]
  1003.     public function offsetSet($name, $child)
  1004.     {
  1005.         $this->add($child);
  1006.     }
  1008.     /**
  1009.      * Removes the child with the given name from the form (implements the \ArrayAccess interface).
  1010.      *
  1011.      * @param string $name The name of the child to remove
  1012.      *
  1013.      * @return void
  1014.      *
  1015.      * @throws AlreadySubmittedException if the form has already been submitted
  1016.      */
  1017.     #[\ReturnTypeWillChange]
  1018.     public function offsetUnset($name)
  1019.     {
  1020.         $this->remove($name);
  1021.     }
  1023.     /**
  1024.      * Returns the iterator for this group.
  1025.      *
  1026.      * @return \Traversable<string, FormInterface>
  1027.      */
  1028.     #[\ReturnTypeWillChange]
  1029.     public function getIterator()
  1030.     {
  1031.         return $this->children;
  1032.     }
  1034.     /**
  1035.      * Returns the number of form children (implements the \Countable interface).
  1036.      *
  1037.      * @return int
  1038.      */
  1039.     #[\ReturnTypeWillChange]
  1040.     public function count()
  1041.     {
  1042.         return \count($this->children);
  1043.     }
  1045.     /**
  1046.      * {@inheritdoc}
  1047.      */
  1048.     public function createView(FormView $parent = null)
  1049.     {
  1050.         if (null === $parent && $this->parent) {
  1051.             $parent = $this->parent->createView();
  1052.         }
  1054.         $type = $this->config->getType();
  1055.         $options = $this->config->getOptions();
  1057.         // The methods createView(), buildView() and finishView() are called
  1058.         // explicitly here in order to be able to override either of them
  1059.         // in a custom resolved form type.
  1060.         $view = $type->createView($this, $parent);
  1062.         $type->buildView($view, $this, $options);
  1064.         foreach ($this->children as $name => $child) {
  1065.             $view->children[$name] = $child->createView($view);
  1066.         }
  1068.         $this->sort($view->children);
  1070.         $type->finishView($view, $this, $options);
  1072.         return $view;
  1073.     }
  1075.     /**
  1076.      * Sorts view fields based on their priority value.
  1077.      */
  1078.     private function sort(array &$children): void
  1079.     {
  1080.         $c = [];
  1081.         $i = 0;
  1082.         $needsSorting = false;
  1083.         foreach ($children as $name => $child) {
  1084.             $c[$name] = ['p' => $child->vars['priority'] ?? 0, 'i' => $i++];
  1086.             if (0 !== $c[$name]['p']) {
  1087.                 $needsSorting = true;
  1088.             }
  1089.         }
  1091.         if (!$needsSorting) {
  1092.             return;
  1093.         }
  1095.         uksort($children, static function ($a, $b) use ($c): int {
  1096.             return [$c[$b]['p'], $c[$a]['i']] <=> [$c[$a]['p'], $c[$b]['i']];
  1097.         });
  1098.     }
  1100.     /**
  1101.      * Normalizes the underlying data if a model transformer is set.
  1102.      *
  1103.      * @return mixed
  1104.      *
  1105.      * @throws TransformationFailedException If the underlying data cannot be transformed to "normalized" format
  1106.      */
  1107.     private function modelToNorm($value)
  1108.     {
  1109.         try {
  1110.             foreach ($this->config->getModelTransformers() as $transformer) {
  1111.                 $value = $transformer->transform($value);
  1112.             }
  1113.         } catch (TransformationFailedException $exception) {
  1114.             throw new TransformationFailedException(sprintf('Unable to transform data for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  1115.         }
  1117.         return $value;
  1118.     }
  1120.     /**
  1121.      * Reverse transforms a value if a model transformer is set.
  1122.      *
  1123.      * @return mixed
  1124.      *
  1125.      * @throws TransformationFailedException If the value cannot be transformed to "model" format
  1126.      */
  1127.     private function normToModel($value)
  1128.     {
  1129.         try {
  1130.             $transformers = $this->config->getModelTransformers();
  1132.             for ($i = \count($transformers) - 1; $i >= 0; --$i) {
  1133.                 $value = $transformers[$i]->reverseTransform($value);
  1134.             }
  1135.         } catch (TransformationFailedException $exception) {
  1136.             throw new TransformationFailedException(sprintf('Unable to reverse value for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  1137.         }
  1139.         return $value;
  1140.     }
  1142.     /**
  1143.      * Transforms the value if a view transformer is set.
  1144.      *
  1145.      * @return mixed
  1146.      *
  1147.      * @throws TransformationFailedException If the normalized value cannot be transformed to "view" format
  1148.      */
  1149.     private function normToView($value)
  1150.     {
  1151.         // Scalar values should  be converted to strings to
  1152.         // facilitate differentiation between empty ("") and zero (0).
  1153.         // Only do this for simple forms, as the resulting value in
  1154.         // compound forms is passed to the data mapper and thus should
  1155.         // not be converted to a string before.
  1156.         if (!($transformers = $this->config->getViewTransformers()) && !$this->config->getCompound()) {
  1157.             return null === $value || is_scalar($value) ? (string) $value : $value;
  1158.         }
  1160.         try {
  1161.             foreach ($transformers as $transformer) {
  1162.                 $value = $transformer->transform($value);
  1163.             }
  1164.         } catch (TransformationFailedException $exception) {
  1165.             throw new TransformationFailedException(sprintf('Unable to transform value for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  1166.         }
  1168.         return $value;
  1169.     }
  1171.     /**
  1172.      * Reverse transforms a value if a view transformer is set.
  1173.      *
  1174.      * @return mixed
  1175.      *
  1176.      * @throws TransformationFailedException If the submitted value cannot be transformed to "normalized" format
  1177.      */
  1178.     private function viewToNorm($value)
  1179.     {
  1180.         if (!$transformers = $this->config->getViewTransformers()) {
  1181.             return '' === $value ? null : $value;
  1182.         }
  1184.         try {
  1185.             for ($i = \count($transformers) - 1; $i >= 0; --$i) {
  1186.                 $value = $transformers[$i]->reverseTransform($value);
  1187.             }
  1188.         } catch (TransformationFailedException $exception) {
  1189.             throw new TransformationFailedException(sprintf('Unable to reverse value for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  1190.         }
  1192.         return $value;
  1193.     }
  1194. }