vendor/symfony/form/Form.php line 69

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\Util\FormUtil;
  26. use Symfony\Component\Form\Util\InheritDataAwareIterator;
  27. use Symfony\Component\Form\Util\OrderedHashMap;
  28. use Symfony\Component\PropertyAccess\PropertyPath;
  29. use Symfony\Component\PropertyAccess\PropertyPathInterface;
  31. /**
  32.  * Form represents a form.
  33.  *
  34.  * To implement your own form fields, you need to have a thorough understanding
  35.  * of the data flow within a form. A form stores its data in three different
  36.  * representations:
  37.  *
  38.  *   (1) the "model" format required by the form's object
  39.  *   (2) the "normalized" format for internal processing
  40.  *   (3) the "view" format used for display simple fields
  41.  *       or map children model data for compound fields
  42.  *
  43.  * A date field, for example, may store a date as "Y-m-d" string (1) in the
  44.  * object. To facilitate processing in the field, this value is normalized
  45.  * to a DateTime object (2). In the HTML representation of your form, a
  46.  * localized string (3) may be presented to and modified by the user, or it could be an array of values
  47.  * to be mapped to choices fields.
  48.  *
  49.  * In most cases, format (1) and format (2) will be the same. For example,
  50.  * a checkbox field uses a Boolean value for both internal processing and
  51.  * storage in the object. In these cases you need to set a view transformer
  52.  * to convert between formats (2) and (3). You can do this by calling
  53.  * addViewTransformer().
  54.  *
  55.  * In some cases though it makes sense to make format (1) configurable. To
  56.  * demonstrate this, let's extend our above date field to store the value
  57.  * either as "Y-m-d" string or as timestamp. Internally we still want to
  58.  * use a DateTime object for processing. To convert the data from string/integer
  59.  * to DateTime you can set a model transformer by calling
  60.  * addModelTransformer(). The normalized data is then converted to the displayed
  61.  * data as described before.
  62.  *
  63.  * The conversions (1) -> (2) -> (3) use the transform methods of the transformers.
  64.  * The conversions (3) -> (2) -> (1) use the reverseTransform methods of the transformers.
  65.  *
  66.  * @author Fabien Potencier <fabien@symfony.com>
  67.  * @author Bernhard Schussek <bschussek@gmail.com>
  68.  */
  69. class Form implements \IteratorAggregate, FormInterface, ClearableErrorsInterface
  70. {
  71.     /**
  72.      * @var FormConfigInterface
  73.      */
  74.     private $config;
  76.     /**
  77.      * @var FormInterface|null
  78.      */
  79.     private $parent;
  81.     /**
  82.      * @var FormInterface[]|OrderedHashMap A map of FormInterface instances
  83.      */
  84.     private $children;
  86.     /**
  87.      * @var FormError[] An array of FormError instances
  88.      */
  89.     private $errors = [];
  91.     /**
  92.      * @var bool
  93.      */
  94.     private $submitted = false;
  96.     /**
  97.      * @var FormInterface|ClickableInterface|null The button that was used to submit the form
  98.      */
  99.     private $clickedButton;
  101.     /**
  102.      * @var mixed
  103.      */
  104.     private $modelData;
  106.     /**
  107.      * @var mixed
  108.      */
  109.     private $normData;
  111.     /**
  112.      * @var mixed
  113.      */
  114.     private $viewData;
  116.     /**
  117.      * @var array The submitted values that don't belong to any children
  118.      */
  119.     private $extraData = [];
  121.     /**
  122.      * @var TransformationFailedException|null The transformation failure generated during submission, if any
  123.      */
  124.     private $transformationFailure;
  126.     /**
  127.      * Whether the form's data has been initialized.
  128.      *
  129.      * When the data is initialized with its default value, that default value
  130.      * is passed through the transformer chain in order to synchronize the
  131.      * model, normalized and view format for the first time. This is done
  132.      * lazily in order to save performance when {@link setData()} is called
  133.      * manually, making the initialization with the configured default value
  134.      * superfluous.
  135.      *
  136.      * @var bool
  137.      */
  138.     private $defaultDataSet = false;
  140.     /**
  141.      * Whether setData() is currently being called.
  142.      *
  143.      * @var bool
  144.      */
  145.     private $lockSetData = false;
  147.     /**
  148.      * @var string
  149.      */
  150.     private $name = '';
  152.     /**
  153.      * @var bool Whether the form inherits its underlying data from its parent
  154.      */
  155.     private $inheritData;
  157.     /**
  158.      * @var PropertyPathInterface|null
  159.      */
  160.     private $propertyPath;
  162.     /**
  163.      * @throws LogicException if a data mapper is not provided for a compound form
  164.      */
  165.     public function __construct(FormConfigInterface $config)
  166.     {
  167.         // Compound forms always need a data mapper, otherwise calls to
  168.         // `setData` and `add` will not lead to the correct population of
  169.         // the child forms.
  170.         if ($config->getCompound() && !$config->getDataMapper()) {
  171.             throw new LogicException('Compound forms need a data mapper.');
  172.         }
  174.         // If the form inherits the data from its parent, it is not necessary
  175.         // to call setData() with the default data.
  176.         if ($this->inheritData = $config->getInheritData()) {
  177.             $this->defaultDataSet = true;
  178.         }
  180.         $this->config = $config;
  181.         $this->children = new OrderedHashMap();
  182.         $this->name = $config->getName();
  183.     }
  185.     public function __clone()
  186.     {
  187.         $this->children = clone $this->children;
  189.         foreach ($this->children as $key => $child) {
  190.             $this->children[$key] = clone $child;
  191.         }
  192.     }
  194.     /**
  195.      * {@inheritdoc}
  196.      */
  197.     public function getConfig()
  198.     {
  199.         return $this->config;
  200.     }
  202.     /**
  203.      * {@inheritdoc}
  204.      */
  205.     public function getName()
  206.     {
  207.         return $this->name;
  208.     }
  210.     /**
  211.      * {@inheritdoc}
  212.      */
  213.     public function getPropertyPath()
  214.     {
  215.         if ($this->propertyPath || $this->propertyPath = $this->config->getPropertyPath()) {
  216.             return $this->propertyPath;
  217.         }
  219.         if ('' === $this->name) {
  220.             return null;
  221.         }
  223.         $parent = $this->parent;
  225.         while ($parent && $parent->getConfig()->getInheritData()) {
  226.             $parent = $parent->getParent();
  227.         }
  229.         if ($parent && null === $parent->getConfig()->getDataClass()) {
  230.             $this->propertyPath = new PropertyPath('['.$this->name.']');
  231.         } else {
  232.             $this->propertyPath = new PropertyPath($this->name);
  233.         }
  235.         return $this->propertyPath;
  236.     }
  238.     /**
  239.      * {@inheritdoc}
  240.      */
  241.     public function isRequired()
  242.     {
  243.         if (null === $this->parent || $this->parent->isRequired()) {
  244.             return $this->config->getRequired();
  245.         }
  247.         return false;
  248.     }
  250.     /**
  251.      * {@inheritdoc}
  252.      */
  253.     public function isDisabled()
  254.     {
  255.         if (null === $this->parent || !$this->parent->isDisabled()) {
  256.             return $this->config->getDisabled();
  257.         }
  259.         return true;
  260.     }
  262.     /**
  263.      * {@inheritdoc}
  264.      */
  265.     public function setParent(FormInterface $parent = null)
  266.     {
  267.         if ($this->submitted) {
  268.             throw new AlreadySubmittedException('You cannot set the parent of a submitted form.');
  269.         }
  271.         if (null !== $parent && '' === $this->name) {
  272.             throw new LogicException('A form with an empty name cannot have a parent form.');
  273.         }
  275.         $this->parent = $parent;
  277.         return $this;
  278.     }
  280.     /**
  281.      * {@inheritdoc}
  282.      */
  283.     public function getParent()
  284.     {
  285.         return $this->parent;
  286.     }
  288.     /**
  289.      * {@inheritdoc}
  290.      */
  291.     public function getRoot()
  292.     {
  293.         return $this->parent ? $this->parent->getRoot() : $this;
  294.     }
  296.     /**
  297.      * {@inheritdoc}
  298.      */
  299.     public function isRoot()
  300.     {
  301.         return null === $this->parent;
  302.     }
  304.     /**
  305.      * {@inheritdoc}
  306.      */
  307.     public function setData($modelData)
  308.     {
  309.         // If the form is submitted while disabled, it is set to submitted, but the data is not
  310.         // changed. In such cases (i.e. when the form is not initialized yet) don't
  311.         // abort this method.
  312.         if ($this->submitted && $this->defaultDataSet) {
  313.             throw new AlreadySubmittedException('You cannot change the data of a submitted form.');
  314.         }
  316.         // If the form inherits its parent's data, disallow data setting to
  317.         // prevent merge conflicts
  318.         if ($this->inheritData) {
  319.             throw new RuntimeException('You cannot change the data of a form inheriting its parent data.');
  320.         }
  322.         // Don't allow modifications of the configured data if the data is locked
  323.         if ($this->config->getDataLocked() && $modelData !== $this->config->getData()) {
  324.             return $this;
  325.         }
  327.         if (\is_object($modelData) && !$this->config->getByReference()) {
  328.             $modelData = clone $modelData;
  329.         }
  331.         if ($this->lockSetData) {
  332.             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.');
  333.         }
  335.         $this->lockSetData = true;
  336.         $dispatcher = $this->config->getEventDispatcher();
  338.         // Hook to change content of the model data before transformation and mapping children
  339.         if ($dispatcher->hasListeners(FormEvents::PRE_SET_DATA)) {
  340.             $event = new PreSetDataEvent($this, $modelData);
  341.             $dispatcher->dispatch($event, FormEvents::PRE_SET_DATA);
  342.             $modelData = $event->getData();
  343.         }
  345.         // Treat data as strings unless a transformer exists
  346.         if (is_scalar($modelData) && !$this->config->getViewTransformers() && !$this->config->getModelTransformers()) {
  347.             $modelData = (string) $modelData;
  348.         }
  350.         // Synchronize representations - must not change the content!
  351.         // Transformation exceptions are not caught on initialization
  352.         $normData = $this->modelToNorm($modelData);
  353.         $viewData = $this->normToView($normData);
  355.         // Validate if view data matches data class (unless empty)
  356.         if (!FormUtil::isEmpty($viewData)) {
  357.             $dataClass = $this->config->getDataClass();
  359.             if (null !== $dataClass && !$viewData instanceof $dataClass) {
  360.                 $actualType = get_debug_type($viewData);
  362.                 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.'".');
  363.             }
  364.         }
  366.         $this->modelData = $modelData;
  367.         $this->normData = $normData;
  368.         $this->viewData = $viewData;
  369.         $this->defaultDataSet = true;
  370.         $this->lockSetData = false;
  372.         // Compound forms don't need to invoke this method if they don't have children
  373.         if (\count($this->children) > 0) {
  374.             // Update child forms from the data (unless their config data is locked)
  375.             $this->config->getDataMapper()->mapDataToForms($viewData, new \RecursiveIteratorIterator(new InheritDataAwareIterator($this->children)));
  376.         }
  378.         if ($dispatcher->hasListeners(FormEvents::POST_SET_DATA)) {
  379.             $event = new PostSetDataEvent($this, $modelData);
  380.             $dispatcher->dispatch($event, FormEvents::POST_SET_DATA);
  381.         }
  383.         return $this;
  384.     }
  386.     /**
  387.      * {@inheritdoc}
  388.      */
  389.     public function getData()
  390.     {
  391.         if ($this->inheritData) {
  392.             if (!$this->parent) {
  393.                 throw new RuntimeException('The form is configured to inherit its parent\'s data, but does not have a parent.');
  394.             }
  396.             return $this->parent->getData();
  397.         }
  399.         if (!$this->defaultDataSet) {
  400.             if ($this->lockSetData) {
  401.                 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.');
  402.             }
  404.             $this->setData($this->config->getData());
  405.         }
  407.         return $this->modelData;
  408.     }
  410.     /**
  411.      * {@inheritdoc}
  412.      */
  413.     public function getNormData()
  414.     {
  415.         if ($this->inheritData) {
  416.             if (!$this->parent) {
  417.                 throw new RuntimeException('The form is configured to inherit its parent\'s data, but does not have a parent.');
  418.             }
  420.             return $this->parent->getNormData();
  421.         }
  423.         if (!$this->defaultDataSet) {
  424.             if ($this->lockSetData) {
  425.                 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.');
  426.             }
  428.             $this->setData($this->config->getData());
  429.         }
  431.         return $this->normData;
  432.     }
  434.     /**
  435.      * {@inheritdoc}
  436.      */
  437.     public function getViewData()
  438.     {
  439.         if ($this->inheritData) {
  440.             if (!$this->parent) {
  441.                 throw new RuntimeException('The form is configured to inherit its parent\'s data, but does not have a parent.');
  442.             }
  444.             return $this->parent->getViewData();
  445.         }
  447.         if (!$this->defaultDataSet) {
  448.             if ($this->lockSetData) {
  449.                 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.');
  450.             }
  452.             $this->setData($this->config->getData());
  453.         }
  455.         return $this->viewData;
  456.     }
  458.     /**
  459.      * {@inheritdoc}
  460.      */
  461.     public function getExtraData()
  462.     {
  463.         return $this->extraData;
  464.     }
  466.     /**
  467.      * {@inheritdoc}
  468.      */
  469.     public function initialize()
  470.     {
  471.         if (null !== $this->parent) {
  472.             throw new RuntimeException('Only root forms should be initialized.');
  473.         }
  475.         // Guarantee that the *_SET_DATA events have been triggered once the
  476.         // form is initialized. This makes sure that dynamically added or
  477.         // removed fields are already visible after initialization.
  478.         if (!$this->defaultDataSet) {
  479.             $this->setData($this->config->getData());
  480.         }
  482.         return $this;
  483.     }
  485.     /**
  486.      * {@inheritdoc}
  487.      */
  488.     public function handleRequest($request = null)
  489.     {
  490.         $this->config->getRequestHandler()->handleRequest($this, $request);
  492.         return $this;
  493.     }
  495.     /**
  496.      * {@inheritdoc}
  497.      */
  498.     public function submit($submittedData, bool $clearMissing = true)
  499.     {
  500.         if ($this->submitted) {
  501.             throw new AlreadySubmittedException('A form can only be submitted once.');
  502.         }
  504.         // Initialize errors in the very beginning so we're sure
  505.         // they are collectable during submission only
  506.         $this->errors = [];
  508.         // Obviously, a disabled form should not change its data upon submission.
  509.         if ($this->isDisabled()) {
  510.             $this->submitted = true;
  512.             return $this;
  513.         }
  515.         // The data must be initialized if it was not initialized yet.
  516.         // This is necessary to guarantee that the *_SET_DATA listeners
  517.         // are always invoked before submit() takes place.
  518.         if (!$this->defaultDataSet) {
  519.             $this->setData($this->config->getData());
  520.         }
  522.         // Treat false as NULL to support binding false to checkboxes.
  523.         // Don't convert NULL to a string here in order to determine later
  524.         // whether an empty value has been submitted or whether no value has
  525.         // been submitted at all. This is important for processing checkboxes
  526.         // and radio buttons with empty values.
  527.         if (false === $submittedData) {
  528.             $submittedData = null;
  529.         } elseif (is_scalar($submittedData)) {
  530.             $submittedData = (string) $submittedData;
  531.         } elseif ($this->config->getRequestHandler()->isFileUpload($submittedData)) {
  532.             if (!$this->config->getOption('allow_file_upload')) {
  533.                 $submittedData = null;
  534.                 $this->transformationFailure = new TransformationFailedException('Submitted data was expected to be text or number, file upload given.');
  535.             }
  536.         } elseif (\is_array($submittedData) && !$this->config->getCompound() && !$this->config->hasOption('multiple')) {
  537.             $submittedData = null;
  538.             $this->transformationFailure = new TransformationFailedException('Submitted data was expected to be text or number, array given.');
  539.         }
  541.         $dispatcher = $this->config->getEventDispatcher();
  543.         $modelData = null;
  544.         $normData = null;
  545.         $viewData = null;
  547.         try {
  548.             if (null !== $this->transformationFailure) {
  549.                 throw $this->transformationFailure;
  550.             }
  552.             // Hook to change content of the data submitted by the browser
  553.             if ($dispatcher->hasListeners(FormEvents::PRE_SUBMIT)) {
  554.                 $event = new PreSubmitEvent($this, $submittedData);
  555.                 $dispatcher->dispatch($event, FormEvents::PRE_SUBMIT);
  556.                 $submittedData = $event->getData();
  557.             }
  559.             // Check whether the form is compound.
  560.             // This check is preferable over checking the number of children,
  561.             // since forms without children may also be compound.
  562.             // (think of empty collection forms)
  563.             if ($this->config->getCompound()) {
  564.                 if (null === $submittedData) {
  565.                     $submittedData = [];
  566.                 }
  568.                 if (!\is_array($submittedData)) {
  569.                     throw new TransformationFailedException('Compound forms expect an array or NULL on submission.');
  570.                 }
  572.                 foreach ($this->children as $name => $child) {
  573.                     $isSubmitted = \array_key_exists($name, $submittedData);
  575.                     if ($isSubmitted || $clearMissing) {
  576.                         $child->submit($isSubmitted ? $submittedData[$name] : null, $clearMissing);
  577.                         unset($submittedData[$name]);
  579.                         if (null !== $this->clickedButton) {
  580.                             continue;
  581.                         }
  583.                         if ($child instanceof ClickableInterface && $child->isClicked()) {
  584.                             $this->clickedButton = $child;
  586.                             continue;
  587.                         }
  589.                         if (method_exists($child, 'getClickedButton') && null !== $child->getClickedButton()) {
  590.                             $this->clickedButton = $child->getClickedButton();
  591.                         }
  592.                     }
  593.                 }
  595.                 $this->extraData = $submittedData;
  596.             }
  598.             // Forms that inherit their parents' data also are not processed,
  599.             // because then it would be too difficult to merge the changes in
  600.             // the child and the parent form. Instead, the parent form also takes
  601.             // changes in the grandchildren (i.e. children of the form that inherits
  602.             // its parent's data) into account.
  603.             // (see InheritDataAwareIterator below)
  604.             if (!$this->inheritData) {
  605.                 // If the form is compound, the view data is merged with the data
  606.                 // of the children using the data mapper.
  607.                 // If the form is not compound, the view data is assigned to the submitted data.
  608.                 $viewData = $this->config->getCompound() ? $this->viewData : $submittedData;
  610.                 if (FormUtil::isEmpty($viewData)) {
  611.                     $emptyData = $this->config->getEmptyData();
  613.                     if ($emptyData instanceof \Closure) {
  614.                         $emptyData = $emptyData($this, $viewData);
  615.                     }
  617.                     $viewData = $emptyData;
  618.                 }
  620.                 // Merge form data from children into existing view data
  621.                 // It is not necessary to invoke this method if the form has no children,
  622.                 // even if it is compound.
  623.                 if (\count($this->children) > 0) {
  624.                     // Use InheritDataAwareIterator to process children of
  625.                     // descendants that inherit this form's data.
  626.                     // These descendants will not be submitted normally (see the check
  627.                     // for $this->config->getInheritData() above)
  628.                     $this->config->getDataMapper()->mapFormsToData(
  629.                         new \RecursiveIteratorIterator(new InheritDataAwareIterator($this->children)),
  630.                         $viewData
  631.                     );
  632.                 }
  634.                 // Normalize data to unified representation
  635.                 $normData = $this->viewToNorm($viewData);
  637.                 // Hook to change content of the data in the normalized
  638.                 // representation
  639.                 if ($dispatcher->hasListeners(FormEvents::SUBMIT)) {
  640.                     $event = new SubmitEvent($this, $normData);
  641.                     $dispatcher->dispatch($event, FormEvents::SUBMIT);
  642.                     $normData = $event->getData();
  643.                 }
  645.                 // Synchronize representations - must not change the content!
  646.                 $modelData = $this->normToModel($normData);
  647.                 $viewData = $this->normToView($normData);
  648.             }
  649.         } catch (TransformationFailedException $e) {
  650.             $this->transformationFailure = $e;
  652.             // If $viewData was not yet set, set it to $submittedData so that
  653.             // the erroneous data is accessible on the form.
  654.             // Forms that inherit data never set any data, because the getters
  655.             // forward to the parent form's getters anyway.
  656.             if (null === $viewData && !$this->inheritData) {
  657.                 $viewData = $submittedData;
  658.             }
  659.         }
  661.         $this->submitted = true;
  662.         $this->modelData = $modelData;
  663.         $this->normData = $normData;
  664.         $this->viewData = $viewData;
  666.         if ($dispatcher->hasListeners(FormEvents::POST_SUBMIT)) {
  667.             $event = new PostSubmitEvent($this, $viewData);
  668.             $dispatcher->dispatch($event, FormEvents::POST_SUBMIT);
  669.         }
  671.         return $this;
  672.     }
  674.     /**
  675.      * {@inheritdoc}
  676.      */
  677.     public function addError(FormError $error)
  678.     {
  679.         if (null === $error->getOrigin()) {
  680.             $error->setOrigin($this);
  681.         }
  683.         if ($this->parent && $this->config->getErrorBubbling()) {
  684.             $this->parent->addError($error);
  685.         } else {
  686.             $this->errors[] = $error;
  687.         }
  689.         return $this;
  690.     }
  692.     /**
  693.      * {@inheritdoc}
  694.      */
  695.     public function isSubmitted()
  696.     {
  697.         return $this->submitted;
  698.     }
  700.     /**
  701.      * {@inheritdoc}
  702.      */
  703.     public function isSynchronized()
  704.     {
  705.         return null === $this->transformationFailure;
  706.     }
  708.     /**
  709.      * {@inheritdoc}
  710.      */
  711.     public function getTransformationFailure()
  712.     {
  713.         return $this->transformationFailure;
  714.     }
  716.     /**
  717.      * {@inheritdoc}
  718.      */
  719.     public function isEmpty()
  720.     {
  721.         foreach ($this->children as $child) {
  722.             if (!$child->isEmpty()) {
  723.                 return false;
  724.             }
  725.         }
  727.         if (!method_exists($this->config, 'getIsEmptyCallback')) {
  728.             trigger_deprecation('symfony/form', '5.1', 'Not implementing the "%s::getIsEmptyCallback()" method in "%s" is deprecated.', FormConfigInterface::class, \get_class($this->config));
  730.             $isEmptyCallback = null;
  731.         } else {
  732.             $isEmptyCallback = $this->config->getIsEmptyCallback();
  733.         }
  735.         if (null !== $isEmptyCallback) {
  736.             return $isEmptyCallback($this->modelData);
  737.         }
  739.         return FormUtil::isEmpty($this->modelData) ||
  740.             // arrays, countables
  741.             ((\is_array($this->modelData) || $this->modelData instanceof \Countable) && 0 === \count($this->modelData)) ||
  742.             // traversables that are not countable
  743.             ($this->modelData instanceof \Traversable && 0 === iterator_count($this->modelData));
  744.     }
  746.     /**
  747.      * {@inheritdoc}
  748.      */
  749.     public function isValid()
  750.     {
  751.         if (!$this->submitted) {
  752.             throw new LogicException('Cannot check if an unsubmitted form is valid. Call Form::isSubmitted() before Form::isValid().');
  753.         }
  755.         if ($this->isDisabled()) {
  756.             return true;
  757.         }
  759.         return 0 === \count($this->getErrors(true));
  760.     }
  762.     /**
  763.      * Returns the button that was used to submit the form.
  764.      *
  765.      * @return FormInterface|ClickableInterface|null
  766.      */
  767.     public function getClickedButton()
  768.     {
  769.         if ($this->clickedButton) {
  770.             return $this->clickedButton;
  771.         }
  773.         return $this->parent && method_exists($this->parent, 'getClickedButton') ? $this->parent->getClickedButton() : null;
  774.     }
  776.     /**
  777.      * {@inheritdoc}
  778.      */
  779.     public function getErrors(bool $deep = false, bool $flatten = true)
  780.     {
  781.         $errors = $this->errors;
  783.         // Copy the errors of nested forms to the $errors array
  784.         if ($deep) {
  785.             foreach ($this as $child) {
  786.                 /** @var FormInterface $child */
  787.                 if ($child->isSubmitted() && $child->isValid()) {
  788.                     continue;
  789.                 }
  791.                 $iterator = $child->getErrors(true, $flatten);
  793.                 if (0 === \count($iterator)) {
  794.                     continue;
  795.                 }
  797.                 if ($flatten) {
  798.                     foreach ($iterator as $error) {
  799.                         $errors[] = $error;
  800.                     }
  801.                 } else {
  802.                     $errors[] = $iterator;
  803.                 }
  804.             }
  805.         }
  807.         return new FormErrorIterator($this, $errors);
  808.     }
  810.     /**
  811.      * {@inheritdoc}
  812.      *
  813.      * @return $this
  814.      */
  815.     public function clearErrors(bool $deep = false): self
  816.     {
  817.         $this->errors = [];
  819.         if ($deep) {
  820.             // Clear errors from children
  821.             foreach ($this as $child) {
  822.                 if ($child instanceof ClearableErrorsInterface) {
  823.                     $child->clearErrors(true);
  824.                 }
  825.             }
  826.         }
  828.         return $this;
  829.     }
  831.     /**
  832.      * {@inheritdoc}
  833.      */
  834.     public function all()
  835.     {
  836.         return iterator_to_array($this->children);
  837.     }
  839.     /**
  840.      * {@inheritdoc}
  841.      */
  842.     public function add($child, string $type = null, array $options = [])
  843.     {
  844.         if ($this->submitted) {
  845.             throw new AlreadySubmittedException('You cannot add children to a submitted form.');
  846.         }
  848.         if (!$this->config->getCompound()) {
  849.             throw new LogicException('You cannot add children to a simple form. Maybe you should set the option "compound" to true?');
  850.         }
  852.         if (!$child instanceof FormInterface) {
  853.             if (!\is_string($child) && !\is_int($child)) {
  854.                 throw new UnexpectedTypeException($child, 'string or Symfony\Component\Form\FormInterface');
  855.             }
  857.             $child = (string) $child;
  859.             if (null !== $type && !\is_string($type)) {
  860.                 throw new UnexpectedTypeException($type, 'string or null');
  861.             }
  863.             // Never initialize child forms automatically
  864.             $options['auto_initialize'] = false;
  866.             if (null === $type && null === $this->config->getDataClass()) {
  867.                 $type = 'Symfony\Component\Form\Extension\Core\Type\TextType';
  868.             }
  870.             if (null === $type) {
  871.                 $child = $this->config->getFormFactory()->createForProperty($this->config->getDataClass(), $child, null, $options);
  872.             } else {
  873.                 $child = $this->config->getFormFactory()->createNamed($child, $type, null, $options);
  874.             }
  875.         } elseif ($child->getConfig()->getAutoInitialize()) {
  876.             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()));
  877.         }
  879.         $this->children[$child->getName()] = $child;
  881.         $child->setParent($this);
  883.         // If setData() is currently being called, there is no need to call
  884.         // mapDataToForms() here, as mapDataToForms() is called at the end
  885.         // of setData() anyway. Not doing this check leads to an endless
  886.         // recursion when initializing the form lazily and an event listener
  887.         // (such as ResizeFormListener) adds fields depending on the data:
  888.         //
  889.         //  * setData() is called, the form is not initialized yet
  890.         //  * add() is called by the listener (setData() is not complete, so
  891.         //    the form is still not initialized)
  892.         //  * getViewData() is called
  893.         //  * setData() is called since the form is not initialized yet
  894.         //  * ... endless recursion ...
  895.         //
  896.         // Also skip data mapping if setData() has not been called yet.
  897.         // setData() will be called upon form initialization and data mapping
  898.         // will take place by then.
  899.         if (!$this->lockSetData && $this->defaultDataSet && !$this->inheritData) {
  900.             $viewData = $this->getViewData();
  901.             $this->config->getDataMapper()->mapDataToForms(
  902.                 $viewData,
  903.                 new \RecursiveIteratorIterator(new InheritDataAwareIterator(new \ArrayIterator([$child->getName() => $child])))
  904.             );
  905.         }
  907.         return $this;
  908.     }
  910.     /**
  911.      * {@inheritdoc}
  912.      */
  913.     public function remove(string $name)
  914.     {
  915.         if ($this->submitted) {
  916.             throw new AlreadySubmittedException('You cannot remove children from a submitted form.');
  917.         }
  919.         if (isset($this->children[$name])) {
  920.             if (!$this->children[$name]->isSubmitted()) {
  921.                 $this->children[$name]->setParent(null);
  922.             }
  924.             unset($this->children[$name]);
  925.         }
  927.         return $this;
  928.     }
  930.     /**
  931.      * {@inheritdoc}
  932.      */
  933.     public function has(string $name)
  934.     {
  935.         return isset($this->children[$name]);
  936.     }
  938.     /**
  939.      * {@inheritdoc}
  940.      */
  941.     public function get(string $name)
  942.     {
  943.         if (isset($this->children[$name])) {
  944.             return $this->children[$name];
  945.         }
  947.         throw new OutOfBoundsException(sprintf('Child "%s" does not exist.', $name));
  948.     }
  950.     /**
  951.      * Returns whether a child with the given name exists (implements the \ArrayAccess interface).
  952.      *
  953.      * @param string $name The name of the child
  954.      *
  955.      * @return bool
  956.      */
  957.     public function offsetExists($name)
  958.     {
  959.         return $this->has($name);
  960.     }
  962.     /**
  963.      * Returns the child with the given name (implements the \ArrayAccess interface).
  964.      *
  965.      * @param string $name The name of the child
  966.      *
  967.      * @return FormInterface The child form
  968.      *
  969.      * @throws OutOfBoundsException if the named child does not exist
  970.      */
  971.     public function offsetGet($name)
  972.     {
  973.         return $this->get($name);
  974.     }
  976.     /**
  977.      * Adds a child to the form (implements the \ArrayAccess interface).
  978.      *
  979.      * @param string        $name  Ignored. The name of the child is used
  980.      * @param FormInterface $child The child to be added
  981.      *
  982.      * @throws AlreadySubmittedException if the form has already been submitted
  983.      * @throws LogicException            when trying to add a child to a non-compound form
  984.      *
  985.      * @see self::add()
  986.      */
  987.     public function offsetSet($name, $child)
  988.     {
  989.         $this->add($child);
  990.     }
  992.     /**
  993.      * Removes the child with the given name from the form (implements the \ArrayAccess interface).
  994.      *
  995.      * @param string $name The name of the child to remove
  996.      *
  997.      * @throws AlreadySubmittedException if the form has already been submitted
  998.      */
  999.     public function offsetUnset($name)
  1000.     {
  1001.         $this->remove($name);
  1002.     }
  1004.     /**
  1005.      * Returns the iterator for this group.
  1006.      *
  1007.      * @return \Traversable|FormInterface[]
  1008.      */
  1009.     public function getIterator()
  1010.     {
  1011.         return $this->children;
  1012.     }
  1014.     /**
  1015.      * Returns the number of form children (implements the \Countable interface).
  1016.      *
  1017.      * @return int The number of embedded form children
  1018.      */
  1019.     public function count()
  1020.     {
  1021.         return \count($this->children);
  1022.     }
  1024.     /**
  1025.      * {@inheritdoc}
  1026.      */
  1027.     public function createView(FormView $parent = null)
  1028.     {
  1029.         if (null === $parent && $this->parent) {
  1030.             $parent = $this->parent->createView();
  1031.         }
  1033.         $type = $this->config->getType();
  1034.         $options = $this->config->getOptions();
  1036.         // The methods createView(), buildView() and finishView() are called
  1037.         // explicitly here in order to be able to override either of them
  1038.         // in a custom resolved form type.
  1039.         $view = $type->createView($this, $parent);
  1041.         $type->buildView($view, $this, $options);
  1043.         foreach ($this->children as $name => $child) {
  1044.             $view->children[$name] = $child->createView($view);
  1045.         }
  1047.         $type->finishView($view, $this, $options);
  1049.         return $view;
  1050.     }
  1052.     /**
  1053.      * Normalizes the underlying data if a model transformer is set.
  1054.      *
  1055.      * @return mixed
  1056.      *
  1057.      * @throws TransformationFailedException If the underlying data cannot be transformed to "normalized" format
  1058.      */
  1059.     private function modelToNorm($value)
  1060.     {
  1061.         try {
  1062.             foreach ($this->config->getModelTransformers() as $transformer) {
  1063.                 $value = $transformer->transform($value);
  1064.             }
  1065.         } catch (TransformationFailedException $exception) {
  1066.             throw new TransformationFailedException(sprintf('Unable to transform data for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  1067.         }
  1069.         return $value;
  1070.     }
  1072.     /**
  1073.      * Reverse transforms a value if a model transformer is set.
  1074.      *
  1075.      * @return mixed
  1076.      *
  1077.      * @throws TransformationFailedException If the value cannot be transformed to "model" format
  1078.      */
  1079.     private function normToModel($value)
  1080.     {
  1081.         try {
  1082.             $transformers = $this->config->getModelTransformers();
  1084.             for ($i = \count($transformers) - 1; $i >= 0; --$i) {
  1085.                 $value = $transformers[$i]->reverseTransform($value);
  1086.             }
  1087.         } catch (TransformationFailedException $exception) {
  1088.             throw new TransformationFailedException(sprintf('Unable to reverse value for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  1089.         }
  1091.         return $value;
  1092.     }
  1094.     /**
  1095.      * Transforms the value if a view transformer is set.
  1096.      *
  1097.      * @return mixed
  1098.      *
  1099.      * @throws TransformationFailedException If the normalized value cannot be transformed to "view" format
  1100.      */
  1101.     private function normToView($value)
  1102.     {
  1103.         // Scalar values should  be converted to strings to
  1104.         // facilitate differentiation between empty ("") and zero (0).
  1105.         // Only do this for simple forms, as the resulting value in
  1106.         // compound forms is passed to the data mapper and thus should
  1107.         // not be converted to a string before.
  1108.         if (!($transformers = $this->config->getViewTransformers()) && !$this->config->getCompound()) {
  1109.             return null === $value || is_scalar($value) ? (string) $value : $value;
  1110.         }
  1112.         try {
  1113.             foreach ($transformers as $transformer) {
  1114.                 $value = $transformer->transform($value);
  1115.             }
  1116.         } catch (TransformationFailedException $exception) {
  1117.             throw new TransformationFailedException(sprintf('Unable to transform value for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  1118.         }
  1120.         return $value;
  1121.     }
  1123.     /**
  1124.      * Reverse transforms a value if a view transformer is set.
  1125.      *
  1126.      * @return mixed
  1127.      *
  1128.      * @throws TransformationFailedException If the submitted value cannot be transformed to "normalized" format
  1129.      */
  1130.     private function viewToNorm($value)
  1131.     {
  1132.         if (!$transformers = $this->config->getViewTransformers()) {
  1133.             return '' === $value ? null : $value;
  1134.         }
  1136.         try {
  1137.             for ($i = \count($transformers) - 1; $i >= 0; --$i) {
  1138.                 $value = $transformers[$i]->reverseTransform($value);
  1139.             }
  1140.         } catch (TransformationFailedException $exception) {
  1141.             throw new TransformationFailedException(sprintf('Unable to reverse value for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  1142.         }
  1144.         return $value;
  1145.     }
  1146. }