vendor/symfony/form/Form.php line 983

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