Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 58

Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 76
Symfony Profiler

vendor/symfony/form/FormInterface.php line 327

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\PropertyAccess\PropertyPathInterface;
  16. /**
  17.  * A form group bundling multiple forms in a hierarchical structure.
  18.  *
  19.  * @author Bernhard Schussek <bschussek@gmail.com>
  20.  *
  21.  * @extends \ArrayAccess<string, FormInterface>
  22.  * @extends \Traversable<string, FormInterface>
  23.  */
  24. interface FormInterface extends \ArrayAccess, \Traversable, \Countable
  25. {
  26.     /**
  27.      * Sets the parent form.
  28.      *
  29.      * @param FormInterface|null $parent The parent form or null if it's the root
  30.      *
  31.      * @return $this
  32.      *
  33.      * @throws Exception\AlreadySubmittedException if the form has already been submitted
  34.      * @throws Exception\LogicException            when trying to set a parent for a form with
  35.      *                                             an empty name
  36.      */
  37.     public function setParent(self $parent = null);
  39.     /**
  40.      * Returns the parent form.
  41.      *
  42.      * @return self|null
  43.      */
  44.     public function getParent();
  46.     /**
  47.      * Adds or replaces a child to the form.
  48.      *
  49.      * @param FormInterface|string $child   The FormInterface instance or the name of the child
  50.      * @param string|null          $type    The child's type, if a name was passed
  51.      * @param array                $options The child's options, if a name was passed
  52.      *
  53.      * @return $this
  54.      *
  55.      * @throws Exception\AlreadySubmittedException if the form has already been submitted
  56.      * @throws Exception\LogicException            when trying to add a child to a non-compound form
  57.      * @throws Exception\UnexpectedTypeException   if $child or $type has an unexpected type
  58.      */
  59.     public function add($child, string $type = null, array $options = []);
  61.     /**
  62.      * Returns the child with the given name.
  63.      *
  64.      * @return self
  65.      *
  66.      * @throws Exception\OutOfBoundsException if the named child does not exist
  67.      */
  68.     public function get(string $name);
  70.     /**
  71.      * Returns whether a child with the given name exists.
  72.      *
  73.      * @return bool
  74.      */
  75.     public function has(string $name);
  77.     /**
  78.      * Removes a child from the form.
  79.      *
  80.      * @return $this
  81.      *
  82.      * @throws Exception\AlreadySubmittedException if the form has already been submitted
  83.      */
  84.     public function remove(string $name);
  86.     /**
  87.      * Returns all children in this group.
  88.      *
  89.      * @return self[]
  90.      */
  91.     public function all();
  93.     /**
  94.      * Returns the errors of this form.
  95.      *
  96.      * @param bool $deep    Whether to include errors of child forms as well
  97.      * @param bool $flatten Whether to flatten the list of errors in case
  98.      *                      $deep is set to true
  99.      *
  100.      * @return FormErrorIterator
  101.      */
  102.     public function getErrors(bool $deep = false, bool $flatten = true);
  104.     /**
  105.      * Updates the form with default model data.
  106.      *
  107.      * @param mixed $modelData The data formatted as expected for the underlying object
  108.      *
  109.      * @return $this
  110.      *
  111.      * @throws Exception\AlreadySubmittedException     If the form has already been submitted
  112.      * @throws Exception\LogicException                if the view data does not match the expected type
  113.      *                                                 according to {@link FormConfigInterface::getDataClass}
  114.      * @throws Exception\RuntimeException              If listeners try to call setData in a cycle or if
  115.      *                                                 the form inherits data from its parent
  116.      * @throws Exception\TransformationFailedException if the synchronization failed
  117.      */
  118.     public function setData($modelData);
  120.     /**
  121.      * Returns the model data in the format needed for the underlying object.
  122.      *
  123.      * @return mixed When the field is not submitted, the default data is returned.
  124.      *               When the field is submitted, the default data has been bound
  125.      *               to the submitted view data.
  126.      *
  127.      * @throws Exception\RuntimeException If the form inherits data but has no parent
  128.      */
  129.     public function getData();
  131.     /**
  132.      * Returns the normalized data of the field, used as internal bridge
  133.      * between model data and view data.
  134.      *
  135.      * @return mixed When the field is not submitted, the default data is returned.
  136.      *               When the field is submitted, the normalized submitted data
  137.      *               is returned if the field is synchronized with the view data,
  138.      *               null otherwise.
  139.      *
  140.      * @throws Exception\RuntimeException If the form inherits data but has no parent
  141.      */
  142.     public function getNormData();
  144.     /**
  145.      * Returns the view data of the field.
  146.      *
  147.      * It may be defined by {@link FormConfigInterface::getDataClass}.
  148.      *
  149.      * There are two cases:
  150.      *
  151.      * - When the form is compound the view data is mapped to the children.
  152.      *   Each child will use its mapped data as model data.
  153.      *   It can be an array, an object or null.
  154.      *
  155.      * - When the form is simple its view data is used to be bound
  156.      *   to the submitted data.
  157.      *   It can be a string or an array.
  158.      *
  159.      * In both cases the view data is the actual altered data on submission.
  160.      *
  161.      * @return mixed
  162.      *
  163.      * @throws Exception\RuntimeException If the form inherits data but has no parent
  164.      */
  165.     public function getViewData();
  167.     /**
  168.      * Returns the extra submitted data.
  169.      *
  170.      * @return array The submitted data which do not belong to a child
  171.      */
  172.     public function getExtraData();
  174.     /**
  175.      * Returns the form's configuration.
  176.      *
  177.      * @return FormConfigInterface
  178.      */
  179.     public function getConfig();
  181.     /**
  182.      * Returns whether the form is submitted.
  183.      *
  184.      * @return bool
  185.      */
  186.     public function isSubmitted();
  188.     /**
  189.      * Returns the name by which the form is identified in forms.
  190.      *
  191.      * Only root forms are allowed to have an empty name.
  192.      *
  193.      * @return string
  194.      */
  195.     public function getName();
  197.     /**
  198.      * Returns the property path that the form is mapped to.
  199.      *
  200.      * @return PropertyPathInterface|null
  201.      */
  202.     public function getPropertyPath();
  204.     /**
  205.      * Adds an error to this form.
  206.      *
  207.      * @return $this
  208.      */
  209.     public function addError(FormError $error);
  211.     /**
  212.      * Returns whether the form and all children are valid.
  213.      *
  214.      * @return bool
  215.      *
  216.      * @throws Exception\LogicException if the form is not submitted
  217.      */
  218.     public function isValid();
  220.     /**
  221.      * Returns whether the form is required to be filled out.
  222.      *
  223.      * If the form has a parent and the parent is not required, this method
  224.      * will always return false. Otherwise the value set with setRequired()
  225.      * is returned.
  226.      *
  227.      * @return bool
  228.      */
  229.     public function isRequired();
  231.     /**
  232.      * Returns whether this form is disabled.
  233.      *
  234.      * The content of a disabled form is displayed, but not allowed to be
  235.      * modified. The validation of modified disabled forms should fail.
  236.      *
  237.      * Forms whose parents are disabled are considered disabled regardless of
  238.      * their own state.
  239.      *
  240.      * @return bool
  241.      */
  242.     public function isDisabled();
  244.     /**
  245.      * Returns whether the form is empty.
  246.      *
  247.      * @return bool
  248.      */
  249.     public function isEmpty();
  251.     /**
  252.      * Returns whether the data in the different formats is synchronized.
  253.      *
  254.      * If the data is not synchronized, you can get the transformation failure
  255.      * by calling {@link getTransformationFailure()}.
  256.      *
  257.      * If the form is not submitted, this method always returns true.
  258.      *
  259.      * @return bool
  260.      */
  261.     public function isSynchronized();
  263.     /**
  264.      * Returns the data transformation failure, if any, during submission.
  265.      *
  266.      * @return Exception\TransformationFailedException|null
  267.      */
  268.     public function getTransformationFailure();
  270.     /**
  271.      * Initializes the form tree.
  272.      *
  273.      * Should be called on the root form after constructing the tree.
  274.      *
  275.      * @return $this
  276.      *
  277.      * @throws Exception\RuntimeException If the form is not the root
  278.      */
  279.     public function initialize();
  281.     /**
  282.      * Inspects the given request and calls {@link submit()} if the form was
  283.      * submitted.
  284.      *
  285.      * Internally, the request is forwarded to the configured
  286.      * {@link RequestHandlerInterface} instance, which determines whether to
  287.      * submit the form or not.
  288.      *
  289.      * @param mixed $request The request to handle
  290.      *
  291.      * @return $this
  292.      */
  293.     public function handleRequest($request = null);
  295.     /**
  296.      * Submits data to the form.
  297.      *
  298.      * @param string|array|null $submittedData The submitted data
  299.      * @param bool              $clearMissing  Whether to set fields to NULL
  300.      *                                         when they are missing in the
  301.      *                                         submitted data. This argument
  302.      *                                         is only used in compound form
  303.      *
  304.      * @return $this
  305.      *
  306.      * @throws Exception\AlreadySubmittedException if the form has already been submitted
  307.      */
  308.     public function submit($submittedData, bool $clearMissing = true);
  310.     /**
  311.      * Returns the root of the form tree.
  312.      *
  313.      * @return self
  314.      */
  315.     public function getRoot();
  317.     /**
  318.      * Returns whether the field is the root of the form tree.
  319.      *
  320.      * @return bool
  321.      */
  322.     public function isRoot();
  324.     /**
  325.      * @return FormView
  326.      */
  327.     public function createView(FormView $parent = null);
  328. }