vendor/symfony/form/Form.php line 1024

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. class Form implements \IteratorAggregate, FormInterface, ClearableErrorsInterface
  71. {
  72.     /**
  73.      * @var FormConfigInterface
  74.      */
  75.     private $config;
  77.     /**
  78.      * @var FormInterface|null
  79.      */
  80.     private $parent;
  82.     /**
  83.      * A map of FormInterface instances.
  84.      *
  85.      * @var FormInterface[]|OrderedHashMap
  86.      */
  87.     private $children;
  89.     /**
  90.      * @var FormError[]
  91.      */
  92.     private $errors = [];
  94.     /**
  95.      * @var bool
  96.      */
  97.     private $submitted = false;
  99.     /**
  100.      * The button that was used to submit the form.
  101.      *
  102.      * @var FormInterface|ClickableInterface|null
  103.      */
  104.     private $clickedButton;
  106.     /**
  107.      * @var mixed
  108.      */
  109.     private $modelData;
  111.     /**
  112.      * @var mixed
  113.      */
  114.     private $normData;
  116.     /**
  117.      * @var mixed
  118.      */
  119.     private $viewData;
  121.     /**
  122.      * The submitted values that don't belong to any children.
  123.      *
  124.      * @var array
  125.      */
  126.     private $extraData = [];
  128.     /**
  129.      * The transformation failure generated during submission, if any.
  130.      *
  131.      * @var TransformationFailedException|null
  132.      */
  133.     private $transformationFailure;
  135.     /**
  136.      * Whether the form's data has been initialized.
  137.      *
  138.      * When the data is initialized with its default value, that default value
  139.      * is passed through the transformer chain in order to synchronize the
  140.      * model, normalized and view format for the first time. This is done
  141.      * lazily in order to save performance when {@link setData()} is called
  142.      * manually, making the initialization with the configured default value
  143.      * superfluous.
  144.      *
  145.      * @var bool
  146.      */
  147.     private $defaultDataSet = false;
  149.     /**
  150.      * Whether setData() is currently being called.
  151.      *
  152.      * @var bool
  153.      */
  154.     private $lockSetData = false;
  156.     /**
  157.      * @var string
  158.      */
  159.     private $name = '';
  161.     /**
  162.      * Whether the form inherits its underlying data from its parent.
  163.      *
  164.      * @var bool
  165.      */
  166.     private $inheritData;
  168.     /**
  169.      * @var PropertyPathInterface|null
  170.      */
  171.     private $propertyPath;
  173.     /**
  174.      * @throws LogicException if a data mapper is not provided for a compound form
  175.      */
  176.     public function __construct(FormConfigInterface $config)
  177.     {
  178.         // Compound forms always need a data mapper, otherwise calls to
  179.         // `setData` and `add` will not lead to the correct population of
  180.         // the child forms.
  181.         if ($config->getCompound() && !$config->getDataMapper()) {
  182.             throw new LogicException('Compound forms need a data mapper.');
  183.         }
  185.         // If the form inherits the data from its parent, it is not necessary
  186.         // to call setData() with the default data.
  187.         if ($this->inheritData = $config->getInheritData()) {
  188.             $this->defaultDataSet = true;
  189.         }
  191.         $this->config = $config;
  192.         $this->children = new OrderedHashMap();
  193.         $this->name = $config->getName();
  194.     }
  196.     public function __clone()
  197.     {
  198.         $this->children = clone $this->children;
  200.         foreach ($this->children as $key => $child) {
  201.             $this->children[$key] = clone $child;
  202.         }
  203.     }
  205.     /**
  206.      * {@inheritdoc}
  207.      */
  208.     public function getConfig()
  209.     {
  210.         return $this->config;
  211.     }
  213.     /**
  214.      * {@inheritdoc}
  215.      */
  216.     public function getName()
  217.     {
  218.         return $this->name;
  219.     }
  221.     /**
  222.      * {@inheritdoc}
  223.      */
  224.     public function getPropertyPath()
  225.     {
  226.         if ($this->propertyPath || $this->propertyPath = $this->config->getPropertyPath()) {
  227.             return $this->propertyPath;
  228.         }
  230.         if ('' === $this->name) {
  231.             return null;
  232.         }
  234.         $parent = $this->parent;
  236.         while ($parent && $parent->getConfig()->getInheritData()) {
  237.             $parent = $parent->getParent();
  238.         }
  240.         if ($parent && null === $parent->getConfig()->getDataClass()) {
  241.             $this->propertyPath = new PropertyPath('['.$this->name.']');
  242.         } else {
  243.             $this->propertyPath = new PropertyPath($this->name);
  244.         }
  246.         return $this->propertyPath;
  247.     }
  249.     /**
  250.      * {@inheritdoc}
  251.      */
  252.     public function isRequired()
  253.     {
  254.         if (null === $this->parent || $this->parent->isRequired()) {
  255.             return $this->config->getRequired();
  256.         }
  258.         return false;
  259.     }
  261.     /**
  262.      * {@inheritdoc}
  263.      */
  264.     public function isDisabled()
  265.     {
  266.         if (null === $this->parent || !$this->parent->isDisabled()) {
  267.             return $this->config->getDisabled();
  268.         }
  270.         return true;
  271.     }
  273.     /**
  274.      * {@inheritdoc}
  275.      */
  276.     public function setParent(FormInterface $parent = null)
  277.     {
  278.         if ($this->submitted) {
  279.             throw new AlreadySubmittedException('You cannot set the parent of a submitted form.');
  280.         }
  282.         if (null !== $parent && '' === $this->name) {
  283.             throw new LogicException('A form with an empty name cannot have a parent form.');
  284.         }
  286.         $this->parent = $parent;
  288.         return $this;
  289.     }
  291.     /**
  292.      * {@inheritdoc}
  293.      */
  294.     public function getParent()
  295.     {
  296.         return $this->parent;
  297.     }
  299.     /**
  300.      * {@inheritdoc}
  301.      */
  302.     public function getRoot()
  303.     {
  304.         return $this->parent ? $this->parent->getRoot() : $this;
  305.     }
  307.     /**
  308.      * {@inheritdoc}
  309.      */
  310.     public function isRoot()
  311.     {
  312.         return null === $this->parent;
  313.     }
  315.     /**
  316.      * {@inheritdoc}
  317.      */
  318.     public function setData($modelData)
  319.     {
  320.         // If the form is submitted while disabled, it is set to submitted, but the data is not
  321.         // changed. In such cases (i.e. when the form is not initialized yet) don't
  322.         // abort this method.
  323.         if ($this->submitted && $this->defaultDataSet) {
  324.             throw new AlreadySubmittedException('You cannot change the data of a submitted form.');
  325.         }
  327.         // If the form inherits its parent's data, disallow data setting to
  328.         // prevent merge conflicts
  329.         if ($this->inheritData) {
  330.             throw new RuntimeException('You cannot change the data of a form inheriting its parent data.');
  331.         }
  333.         // Don't allow modifications of the configured data if the data is locked
  334.         if ($this->config->getDataLocked() && $modelData !== $this->config->getData()) {
  335.             return $this;
  336.         }
  338.         if (\is_object($modelData) && !$this->config->getByReference()) {
  339.             $modelData = clone $modelData;
  340.         }
  342.         if ($this->lockSetData) {
  343.             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.');
  344.         }
  346.         $this->lockSetData = true;
  347.         $dispatcher = $this->config->getEventDispatcher();
  349.         // Hook to change content of the model data before transformation and mapping children
  350.         if ($dispatcher->hasListeners(FormEvents::PRE_SET_DATA)) {
  351.             $event = new PreSetDataEvent($this, $modelData);
  352.             $dispatcher->dispatch($event, FormEvents::PRE_SET_DATA);
  353.             $modelData = $event->getData();
  354.         }
  356.         // Treat data as strings unless a transformer exists
  357.         if (is_scalar($modelData) && !$this->config->getViewTransformers() && !$this->config->getModelTransformers()) {
  358.             $modelData = (string) $modelData;
  359.         }
  361.         // Synchronize representations - must not change the content!
  362.         // Transformation exceptions are not caught on initialization
  363.         $normData = $this->modelToNorm($modelData);
  364.         $viewData = $this->normToView($normData);
  366.         // Validate if view data matches data class (unless empty)
  367.         if (!FormUtil::isEmpty($viewData)) {
  368.             $dataClass = $this->config->getDataClass();
  370.             if (null !== $dataClass && !$viewData instanceof $dataClass) {
  371.                 $actualType = get_debug_type($viewData);
  373.                 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.'".');
  374.             }
  375.         }
  377.         $this->modelData = $modelData;
  378.         $this->normData = $normData;
  379.         $this->viewData = $viewData;
  380.         $this->defaultDataSet = true;
  381.         $this->lockSetData = false;
  383.         // Compound forms don't need to invoke this method if they don't have children
  384.         if (\count($this->children) > 0) {
  385.             // Update child forms from the data (unless their config data is locked)
  386.             $this->config->getDataMapper()->mapDataToForms($viewData, new \RecursiveIteratorIterator(new InheritDataAwareIterator($this->children)));
  387.         }
  389.         if ($dispatcher->hasListeners(FormEvents::POST_SET_DATA)) {
  390.             $event = new PostSetDataEvent($this, $modelData);
  391.             $dispatcher->dispatch($event, FormEvents::POST_SET_DATA);
  392.         }
  394.         return $this;
  395.     }
  397.     /**
  398.      * {@inheritdoc}
  399.      */
  400.     public function getData()
  401.     {
  402.         if ($this->inheritData) {
  403.             if (!$this->parent) {
  404.                 throw new RuntimeException('The form is configured to inherit its parent\'s data, but does not have a parent.');
  405.             }
  407.             return $this->parent->getData();
  408.         }
  410.         if (!$this->defaultDataSet) {
  411.             if ($this->lockSetData) {
  412.                 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.');
  413.             }
  415.             $this->setData($this->config->getData());
  416.         }
  418.         return $this->modelData;
  419.     }
  421.     /**
  422.      * {@inheritdoc}
  423.      */
  424.     public function getNormData()
  425.     {
  426.         if ($this->inheritData) {
  427.             if (!$this->parent) {
  428.                 throw new RuntimeException('The form is configured to inherit its parent\'s data, but does not have a parent.');
  429.             }
  431.             return $this->parent->getNormData();
  432.         }
  434.         if (!$this->defaultDataSet) {
  435.             if ($this->lockSetData) {
  436.                 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.');
  437.             }
  439.             $this->setData($this->config->getData());
  440.         }
  442.         return $this->normData;
  443.     }
  445.     /**
  446.      * {@inheritdoc}
  447.      */
  448.     public function getViewData()
  449.     {
  450.         if ($this->inheritData) {
  451.             if (!$this->parent) {
  452.                 throw new RuntimeException('The form is configured to inherit its parent\'s data, but does not have a parent.');
  453.             }
  455.             return $this->parent->getViewData();
  456.         }
  458.         if (!$this->defaultDataSet) {
  459.             if ($this->lockSetData) {
  460.                 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.');
  461.             }
  463.             $this->setData($this->config->getData());
  464.         }
  466.         return $this->viewData;
  467.     }
  469.     /**
  470.      * {@inheritdoc}
  471.      */
  472.     public function getExtraData()
  473.     {
  474.         return $this->extraData;
  475.     }
  477.     /**
  478.      * {@inheritdoc}
  479.      */
  480.     public function initialize()
  481.     {
  482.         if (null !== $this->parent) {
  483.             throw new RuntimeException('Only root forms should be initialized.');
  484.         }
  486.         // Guarantee that the *_SET_DATA events have been triggered once the
  487.         // form is initialized. This makes sure that dynamically added or
  488.         // removed fields are already visible after initialization.
  489.         if (!$this->defaultDataSet) {
  490.             $this->setData($this->config->getData());
  491.         }
  493.         return $this;
  494.     }
  496.     /**
  497.      * {@inheritdoc}
  498.      */
  499.     public function handleRequest($request = null)
  500.     {
  501.         $this->config->getRequestHandler()->handleRequest($this, $request);
  503.         return $this;
  504.     }
  506.     /**
  507.      * {@inheritdoc}
  508.      */
  509.     public function submit($submittedData, bool $clearMissing = true)
  510.     {
  511.         if ($this->submitted) {
  512.             throw new AlreadySubmittedException('A form can only be submitted once.');
  513.         }
  515.         // Initialize errors in the very beginning so we're sure
  516.         // they are collectable during submission only
  517.         $this->errors = [];
  519.         // Obviously, a disabled form should not change its data upon submission.
  520.         if ($this->isDisabled()) {
  521.             $this->submitted = true;
  523.             return $this;
  524.         }
  526.         // The data must be initialized if it was not initialized yet.
  527.         // This is necessary to guarantee that the *_SET_DATA listeners
  528.         // are always invoked before submit() takes place.
  529.         if (!$this->defaultDataSet) {
  530.             $this->setData($this->config->getData());
  531.         }
  533.         // Treat false as NULL to support binding false to checkboxes.
  534.         // Don't convert NULL to a string here in order to determine later
  535.         // whether an empty value has been submitted or whether no value has
  536.         // been submitted at all. This is important for processing checkboxes
  537.         // and radio buttons with empty values.
  538.         if (false === $submittedData) {
  539.             $submittedData = null;
  540.         } elseif (is_scalar($submittedData)) {
  541.             $submittedData = (string) $submittedData;
  542.         } elseif ($this->config->getRequestHandler()->isFileUpload($submittedData)) {
  543.             if (!$this->config->getOption('allow_file_upload')) {
  544.                 $submittedData = null;
  545.                 $this->transformationFailure = new TransformationFailedException('Submitted data was expected to be text or number, file upload given.');
  546.             }
  547.         } elseif (\is_array($submittedData) && !$this->config->getCompound() && !$this->config->hasOption('multiple')) {
  548.             $submittedData = null;
  549.             $this->transformationFailure = new TransformationFailedException('Submitted data was expected to be text or number, array given.');
  550.         }
  552.         $dispatcher = $this->config->getEventDispatcher();
  554.         $modelData = null;
  555.         $normData = null;
  556.         $viewData = null;
  558.         try {
  559.             if (null !== $this->transformationFailure) {
  560.                 throw $this->transformationFailure;
  561.             }
  563.             // Hook to change content of the data submitted by the browser
  564.             if ($dispatcher->hasListeners(FormEvents::PRE_SUBMIT)) {
  565.                 $event = new PreSubmitEvent($this, $submittedData);
  566.                 $dispatcher->dispatch($event, FormEvents::PRE_SUBMIT);
  567.                 $submittedData = $event->getData();
  568.             }
  570.             // Check whether the form is compound.
  571.             // This check is preferable over checking the number of children,
  572.             // since forms without children may also be compound.
  573.             // (think of empty collection forms)
  574.             if ($this->config->getCompound()) {
  575.                 if (null === $submittedData) {
  576.                     $submittedData = [];
  577.                 }
  579.                 if (!\is_array($submittedData)) {
  580.                     throw new TransformationFailedException('Compound forms expect an array or NULL on submission.');
  581.                 }
  583.                 foreach ($this->children as $name => $child) {
  584.                     $isSubmitted = \array_key_exists($name, $submittedData);
  586.                     if ($isSubmitted || $clearMissing) {
  587.                         $child->submit($isSubmitted ? $submittedData[$name] : null, $clearMissing);
  588.                         unset($submittedData[$name]);
  590.                         if (null !== $this->clickedButton) {
  591.                             continue;
  592.                         }
  594.                         if ($child instanceof ClickableInterface && $child->isClicked()) {
  595.                             $this->clickedButton = $child;
  597.                             continue;
  598.                         }
  600.                         if (method_exists($child, 'getClickedButton') && null !== $child->getClickedButton()) {
  601.                             $this->clickedButton = $child->getClickedButton();
  602.                         }
  603.                     }
  604.                 }
  606.                 $this->extraData = $submittedData;
  607.             }
  609.             // Forms that inherit their parents' data also are not processed,
  610.             // because then it would be too difficult to merge the changes in
  611.             // the child and the parent form. Instead, the parent form also takes
  612.             // changes in the grandchildren (i.e. children of the form that inherits
  613.             // its parent's data) into account.
  614.             // (see InheritDataAwareIterator below)
  615.             if (!$this->inheritData) {
  616.                 // If the form is compound, the view data is merged with the data
  617.                 // of the children using the data mapper.
  618.                 // If the form is not compound, the view data is assigned to the submitted data.
  619.                 $viewData = $this->config->getCompound() ? $this->viewData : $submittedData;
  621.                 if (FormUtil::isEmpty($viewData)) {
  622.                     $emptyData = $this->config->getEmptyData();
  624.                     if ($emptyData instanceof \Closure) {
  625.                         $emptyData = $emptyData($this, $viewData);
  626.                     }
  628.                     $viewData = $emptyData;
  629.                 }
  631.                 // Merge form data from children into existing view data
  632.                 // It is not necessary to invoke this method if the form has no children,
  633.                 // even if it is compound.
  634.                 if (\count($this->children) > 0) {
  635.                     // Use InheritDataAwareIterator to process children of
  636.                     // descendants that inherit this form's data.
  637.                     // These descendants will not be submitted normally (see the check
  638.                     // for $this->config->getInheritData() above)
  639.                     $this->config->getDataMapper()->mapFormsToData(
  640.                         new \RecursiveIteratorIterator(new InheritDataAwareIterator($this->children)),
  641.                         $viewData
  642.                     );
  643.                 }
  645.                 // Normalize data to unified representation
  646.                 $normData = $this->viewToNorm($viewData);
  648.                 // Hook to change content of the data in the normalized
  649.                 // representation
  650.                 if ($dispatcher->hasListeners(FormEvents::SUBMIT)) {
  651.                     $event = new SubmitEvent($this, $normData);
  652.                     $dispatcher->dispatch($event, FormEvents::SUBMIT);
  653.                     $normData = $event->getData();
  654.                 }
  656.                 // Synchronize representations - must not change the content!
  657.                 $modelData = $this->normToModel($normData);
  658.                 $viewData = $this->normToView($normData);
  659.             }
  660.         } catch (TransformationFailedException $e) {
  661.             $this->transformationFailure = $e;
  663.             // If $viewData was not yet set, set it to $submittedData so that
  664.             // the erroneous data is accessible on the form.
  665.             // Forms that inherit data never set any data, because the getters
  666.             // forward to the parent form's getters anyway.
  667.             if (null === $viewData && !$this->inheritData) {
  668.                 $viewData = $submittedData;
  669.             }
  670.         }
  672.         $this->submitted = true;
  673.         $this->modelData = $modelData;
  674.         $this->normData = $normData;
  675.         $this->viewData = $viewData;
  677.         if ($dispatcher->hasListeners(FormEvents::POST_SUBMIT)) {
  678.             $event = new PostSubmitEvent($this, $viewData);
  679.             $dispatcher->dispatch($event, FormEvents::POST_SUBMIT);
  680.         }
  682.         return $this;
  683.     }
  685.     /**
  686.      * {@inheritdoc}
  687.      */
  688.     public function addError(FormError $error)
  689.     {
  690.         if (null === $error->getOrigin()) {
  691.             $error->setOrigin($this);
  692.         }
  694.         if ($this->parent && $this->config->getErrorBubbling()) {
  695.             $this->parent->addError($error);
  696.         } else {
  697.             $this->errors[] = $error;
  698.         }
  700.         return $this;
  701.     }
  703.     /**
  704.      * {@inheritdoc}
  705.      */
  706.     public function isSubmitted()
  707.     {
  708.         return $this->submitted;
  709.     }
  711.     /**
  712.      * {@inheritdoc}
  713.      */
  714.     public function isSynchronized()
  715.     {
  716.         return null === $this->transformationFailure;
  717.     }
  719.     /**
  720.      * {@inheritdoc}
  721.      */
  722.     public function getTransformationFailure()
  723.     {
  724.         return $this->transformationFailure;
  725.     }
  727.     /**
  728.      * {@inheritdoc}
  729.      */
  730.     public function isEmpty()
  731.     {
  732.         foreach ($this->children as $child) {
  733.             if (!$child->isEmpty()) {
  734.                 return false;
  735.             }
  736.         }
  738.         if (!method_exists($this->config, 'getIsEmptyCallback')) {
  739.             trigger_deprecation('symfony/form', '5.1', 'Not implementing the "%s::getIsEmptyCallback()" method in "%s" is deprecated.', FormConfigInterface::class, \get_class($this->config));
  741.             $isEmptyCallback = null;
  742.         } else {
  743.             $isEmptyCallback = $this->config->getIsEmptyCallback();
  744.         }
  746.         if (null !== $isEmptyCallback) {
  747.             return $isEmptyCallback($this->modelData);
  748.         }
  750.         return FormUtil::isEmpty($this->modelData) ||
  751.             // arrays, countables
  752.             ((\is_array($this->modelData) || $this->modelData instanceof \Countable) && 0 === \count($this->modelData)) ||
  753.             // traversables that are not countable
  754.             ($this->modelData instanceof \Traversable && 0 === iterator_count($this->modelData));
  755.     }
  757.     /**
  758.      * {@inheritdoc}
  759.      */
  760.     public function isValid()
  761.     {
  762.         if (!$this->submitted) {
  763.             throw new LogicException('Cannot check if an unsubmitted form is valid. Call Form::isSubmitted() before Form::isValid().');
  764.         }
  766.         if ($this->isDisabled()) {
  767.             return true;
  768.         }
  770.         return 0 === \count($this->getErrors(true));
  771.     }
  773.     /**
  774.      * Returns the button that was used to submit the form.
  775.      *
  776.      * @return FormInterface|ClickableInterface|null
  777.      */
  778.     public function getClickedButton()
  779.     {
  780.         if ($this->clickedButton) {
  781.             return $this->clickedButton;
  782.         }
  784.         return $this->parent && method_exists($this->parent, 'getClickedButton') ? $this->parent->getClickedButton() : null;
  785.     }
  787.     /**
  788.      * {@inheritdoc}
  789.      */
  790.     public function getErrors(bool $deep = false, bool $flatten = true)
  791.     {
  792.         $errors = $this->errors;
  794.         // Copy the errors of nested forms to the $errors array
  795.         if ($deep) {
  796.             foreach ($this as $child) {
  797.                 /** @var FormInterface $child */
  798.                 if ($child->isSubmitted() && $child->isValid()) {
  799.                     continue;
  800.                 }
  802.                 $iterator = $child->getErrors(true, $flatten);
  804.                 if (0 === \count($iterator)) {
  805.                     continue;
  806.                 }
  808.                 if ($flatten) {
  809.                     foreach ($iterator as $error) {
  810.                         $errors[] = $error;
  811.                     }
  812.                 } else {
  813.                     $errors[] = $iterator;
  814.                 }
  815.             }
  816.         }
  818.         return new FormErrorIterator($this, $errors);
  819.     }
  821.     /**
  822.      * {@inheritdoc}
  823.      *
  824.      * @return $this
  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.     public function offsetExists($name)
  969.     {
  970.         return $this->has($name);
  971.     }
  973.     /**
  974.      * Returns the child with the given name (implements the \ArrayAccess interface).
  975.      *
  976.      * @param string $name The name of the child
  977.      *
  978.      * @return FormInterface The child form
  979.      *
  980.      * @throws OutOfBoundsException if the named child does not exist
  981.      */
  982.     public function offsetGet($name)
  983.     {
  984.         return $this->get($name);
  985.     }
  987.     /**
  988.      * Adds a child to the form (implements the \ArrayAccess interface).
  989.      *
  990.      * @param string        $name  Ignored. The name of the child is used
  991.      * @param FormInterface $child The child to be added
  992.      *
  993.      * @return void
  994.      *
  995.      * @throws AlreadySubmittedException if the form has already been submitted
  996.      * @throws LogicException            when trying to add a child to a non-compound form
  997.      *
  998.      * @see self::add()
  999.      */
  1000.     public function offsetSet($name, $child)
  1001.     {
  1002.         $this->add($child);
  1003.     }
  1005.     /**
  1006.      * Removes the child with the given name from the form (implements the \ArrayAccess interface).
  1007.      *
  1008.      * @param string $name The name of the child to remove
  1009.      *
  1010.      * @return void
  1011.      *
  1012.      * @throws AlreadySubmittedException if the form has already been submitted
  1013.      */
  1014.     public function offsetUnset($name)
  1015.     {
  1016.         $this->remove($name);
  1017.     }
  1019.     /**
  1020.      * Returns the iterator for this group.
  1021.      *
  1022.      * @return \Traversable<FormInterface>
  1023.      */
  1024.     public function getIterator()
  1025.     {
  1026.         return $this->children;
  1027.     }
  1029.     /**
  1030.      * Returns the number of form children (implements the \Countable interface).
  1031.      *
  1032.      * @return int The number of embedded form children
  1033.      */
  1034.     public function count()
  1035.     {
  1036.         return \count($this->children);
  1037.     }
  1039.     /**
  1040.      * {@inheritdoc}
  1041.      */
  1042.     public function createView(FormView $parent = null)
  1043.     {
  1044.         if (null === $parent && $this->parent) {
  1045.             $parent = $this->parent->createView();
  1046.         }
  1048.         $type = $this->config->getType();
  1049.         $options = $this->config->getOptions();
  1051.         // The methods createView(), buildView() and finishView() are called
  1052.         // explicitly here in order to be able to override either of them
  1053.         // in a custom resolved form type.
  1054.         $view = $type->createView($this, $parent);
  1056.         $type->buildView($view, $this, $options);
  1058.         foreach ($this->children as $name => $child) {
  1059.             $view->children[$name] = $child->createView($view);
  1060.         }
  1062.         $type->finishView($view, $this, $options);
  1064.         return $view;
  1065.     }
  1067.     /**
  1068.      * Normalizes the underlying data if a model transformer is set.
  1069.      *
  1070.      * @return mixed
  1071.      *
  1072.      * @throws TransformationFailedException If the underlying data cannot be transformed to "normalized" format
  1073.      */
  1074.     private function modelToNorm($value)
  1075.     {
  1076.         try {
  1077.             foreach ($this->config->getModelTransformers() as $transformer) {
  1078.                 $value = $transformer->transform($value);
  1079.             }
  1080.         } catch (TransformationFailedException $exception) {
  1081.             throw new TransformationFailedException(sprintf('Unable to transform data for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  1082.         }
  1084.         return $value;
  1085.     }
  1087.     /**
  1088.      * Reverse transforms a value if a model transformer is set.
  1089.      *
  1090.      * @return mixed
  1091.      *
  1092.      * @throws TransformationFailedException If the value cannot be transformed to "model" format
  1093.      */
  1094.     private function normToModel($value)
  1095.     {
  1096.         try {
  1097.             $transformers = $this->config->getModelTransformers();
  1099.             for ($i = \count($transformers) - 1; $i >= 0; --$i) {
  1100.                 $value = $transformers[$i]->reverseTransform($value);
  1101.             }
  1102.         } catch (TransformationFailedException $exception) {
  1103.             throw new TransformationFailedException(sprintf('Unable to reverse value for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  1104.         }
  1106.         return $value;
  1107.     }
  1109.     /**
  1110.      * Transforms the value if a view transformer is set.
  1111.      *
  1112.      * @return mixed
  1113.      *
  1114.      * @throws TransformationFailedException If the normalized value cannot be transformed to "view" format
  1115.      */
  1116.     private function normToView($value)
  1117.     {
  1118.         // Scalar values should  be converted to strings to
  1119.         // facilitate differentiation between empty ("") and zero (0).
  1120.         // Only do this for simple forms, as the resulting value in
  1121.         // compound forms is passed to the data mapper and thus should
  1122.         // not be converted to a string before.
  1123.         if (!($transformers = $this->config->getViewTransformers()) && !$this->config->getCompound()) {
  1124.             return null === $value || is_scalar($value) ? (string) $value : $value;
  1125.         }
  1127.         try {
  1128.             foreach ($transformers as $transformer) {
  1129.                 $value = $transformer->transform($value);
  1130.             }
  1131.         } catch (TransformationFailedException $exception) {
  1132.             throw new TransformationFailedException(sprintf('Unable to transform value for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  1133.         }
  1135.         return $value;
  1136.     }
  1138.     /**
  1139.      * Reverse transforms a value if a view transformer is set.
  1140.      *
  1141.      * @return mixed
  1142.      *
  1143.      * @throws TransformationFailedException If the submitted value cannot be transformed to "normalized" format
  1144.      */
  1145.     private function viewToNorm($value)
  1146.     {
  1147.         if (!$transformers = $this->config->getViewTransformers()) {
  1148.             return '' === $value ? null : $value;
  1149.         }
  1151.         try {
  1152.             for ($i = \count($transformers) - 1; $i >= 0; --$i) {
  1153.                 $value = $transformers[$i]->reverseTransform($value);
  1154.             }
  1155.         } catch (TransformationFailedException $exception) {
  1156.             throw new TransformationFailedException(sprintf('Unable to reverse value for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  1157.         }
  1159.         return $value;
  1160.     }
  1161. }