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/validator/Context/ExecutionContextInterface.php line 132

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\Validator\Context;
  14. use Symfony\Component\Validator\Constraint;
  15. use Symfony\Component\Validator\ConstraintViolationListInterface;
  16. use Symfony\Component\Validator\Mapping;
  17. use Symfony\Component\Validator\Mapping\MetadataInterface;
  18. use Symfony\Component\Validator\Validator\ValidatorInterface;
  19. use Symfony\Component\Validator\Violation\ConstraintViolationBuilderInterface;
  21. /**
  22.  * The context of a validation run.
  23.  *
  24.  * The context collects all violations generated during the validation. By
  25.  * default, validators execute all validations in a new context:
  26.  *
  27.  *     $violations = $validator->validate($object);
  28.  *
  29.  * When you make another call to the validator, while the validation is in
  30.  * progress, the violations will be isolated from each other:
  31.  *
  32.  *     public function validate($value, Constraint $constraint)
  33.  *     {
  34.  *         $validator = $this->context->getValidator();
  35.  *
  36.  *         // The violations are not added to $this->context
  37.  *         $violations = $validator->validate($value);
  38.  *     }
  39.  *
  40.  * However, if you want to add the violations to the current context, use the
  41.  * {@link ValidatorInterface::inContext()} method:
  42.  *
  43.  *     public function validate($value, Constraint $constraint)
  44.  *     {
  45.  *         $validator = $this->context->getValidator();
  46.  *
  47.  *         // The violations are added to $this->context
  48.  *         $validator
  49.  *             ->inContext($this->context)
  50.  *             ->validate($value)
  51.  *         ;
  52.  *     }
  53.  *
  54.  * Additionally, the context provides information about the current state of
  55.  * the validator, such as the currently validated class, the name of the
  56.  * currently validated property and more. These values change over time, so you
  57.  * cannot store a context and expect that the methods still return the same
  58.  * results later on.
  59.  *
  60.  * @author Bernhard Schussek <bschussek@gmail.com>
  61.  */
  62. interface ExecutionContextInterface
  63. {
  64.     /**
  65.      * Adds a violation at the current node of the validation graph.
  66.      *
  67.      * @param string|\Stringable $message The error message as a string or a stringable object
  68.      * @param array              $params  The parameters substituted in the error message
  69.      */
  70.     public function addViolation(string $message, array $params = []);
  72.     /**
  73.      * Returns a builder for adding a violation with extended information.
  74.      *
  75.      * Call {@link ConstraintViolationBuilderInterface::addViolation()} to
  76.      * add the violation when you're done with the configuration:
  77.      *
  78.      *     $context->buildViolation('Please enter a number between %min% and %max%.')
  79.      *         ->setParameter('%min%', '3')
  80.      *         ->setParameter('%max%', '10')
  81.      *         ->setTranslationDomain('number_validation')
  82.      *         ->addViolation();
  83.      *
  84.      * @param string|\Stringable $message    The error message as a string or a stringable object
  85.      * @param array              $parameters The parameters substituted in the error message
  86.      *
  87.      * @return ConstraintViolationBuilderInterface
  88.      */
  89.     public function buildViolation(string $message, array $parameters = []);
  91.     /**
  92.      * Returns the validator.
  93.      *
  94.      * Useful if you want to validate additional constraints:
  95.      *
  96.      *     public function validate($value, Constraint $constraint)
  97.      *     {
  98.      *         $validator = $this->context->getValidator();
  99.      *
  100.      *         $violations = $validator->validate($value, new Length(['min' => 3]));
  101.      *
  102.      *         if (count($violations) > 0) {
  103.      *             // ...
  104.      *         }
  105.      *     }
  106.      *
  107.      * @return ValidatorInterface
  108.      */
  109.     public function getValidator();
  111.     /**
  112.      * Returns the currently validated object.
  113.      *
  114.      * If the validator is currently validating a class constraint, the
  115.      * object of that class is returned. If it is validating a property or
  116.      * getter constraint, the object that the property/getter belongs to is
  117.      * returned.
  118.      *
  119.      * In other cases, null is returned.
  120.      *
  121.      * @return object|null
  122.      */
  123.     public function getObject();
  125.     /**
  126.      * Warning: Should not be called by user code, to be used by the validator engine only.
  127.      *
  128.      * @param mixed       $value        The validated value
  129.      * @param object|null $object       The currently validated object
  130.      * @param string      $propertyPath The property path to the current value
  131.      */
  132.     public function setNode($value, ?object $object, MetadataInterface $metadata = null, string $propertyPath);
  134.     /**
  135.      * Warning: Should not be called by user code, to be used by the validator engine only.
  136.      *
  137.      * @param string|null $group The validated group
  138.      */
  139.     public function setGroup(?string $group);
  141.     /**
  142.      * Warning: Should not be called by user code, to be used by the validator engine only.
  143.      */
  144.     public function setConstraint(Constraint $constraint);
  146.     /**
  147.      * Warning: Should not be called by user code, to be used by the validator engine only.
  148.      *
  149.      * @param string $cacheKey  The hash of the object
  150.      * @param string $groupHash The group's name or hash, if it is group
  151.      *                          sequence
  152.      */
  153.     public function markGroupAsValidated(string $cacheKey, string $groupHash);
  155.     /**
  156.      * Warning: Should not be called by user code, to be used by the validator engine only.
  157.      *
  158.      * @param string $cacheKey  The hash of the object
  159.      * @param string $groupHash The group's name or hash, if it is group
  160.      *                          sequence
  161.      *
  162.      * @return bool
  163.      */
  164.     public function isGroupValidated(string $cacheKey, string $groupHash);
  166.     /**
  167.      * Warning: Should not be called by user code, to be used by the validator engine only.
  168.      *
  169.      * @param string $cacheKey       The hash of the object
  170.      * @param string $constraintHash The hash of the constraint
  171.      */
  172.     public function markConstraintAsValidated(string $cacheKey, string $constraintHash);
  174.     /**
  175.      * Warning: Should not be called by user code, to be used by the validator engine only.
  176.      *
  177.      * @param string $cacheKey       The hash of the object
  178.      * @param string $constraintHash The hash of the constraint
  179.      *
  180.      * @return bool
  181.      */
  182.     public function isConstraintValidated(string $cacheKey, string $constraintHash);
  184.     /**
  185.      * Warning: Should not be called by user code, to be used by the validator engine only.
  186.      *
  187.      * @param string $cacheKey The hash of the object
  188.      *
  189.      * @see ObjectInitializerInterface
  190.      */
  191.     public function markObjectAsInitialized(string $cacheKey);
  193.     /**
  194.      * Warning: Should not be called by user code, to be used by the validator engine only.
  195.      *
  196.      * @param string $cacheKey The hash of the object
  197.      *
  198.      * @return bool
  199.      *
  200.      * @see ObjectInitializerInterface
  201.      */
  202.     public function isObjectInitialized(string $cacheKey);
  204.     /**
  205.      * Returns the violations generated by the validator so far.
  206.      *
  207.      * @return ConstraintViolationListInterface
  208.      */
  209.     public function getViolations();
  211.     /**
  212.      * Returns the value at which validation was started in the object graph.
  213.      *
  214.      * The validator, when given an object, traverses the properties and
  215.      * related objects and their properties. The root of the validation is the
  216.      * object from which the traversal started.
  217.      *
  218.      * The current value is returned by {@link getValue}.
  219.      *
  220.      * @return mixed
  221.      */
  222.     public function getRoot();
  224.     /**
  225.      * Returns the value that the validator is currently validating.
  226.      *
  227.      * If you want to retrieve the object that was originally passed to the
  228.      * validator, use {@link getRoot}.
  229.      *
  230.      * @return mixed
  231.      */
  232.     public function getValue();
  234.     /**
  235.      * Returns the metadata for the currently validated value.
  236.      *
  237.      * With the core implementation, this method returns a
  238.      * {@link Mapping\ClassMetadataInterface} instance if the current value is an object,
  239.      * a {@link Mapping\PropertyMetadata} instance if the current value is
  240.      * the value of a property and a {@link Mapping\GetterMetadata} instance if
  241.      * the validated value is the result of a getter method.
  242.      *
  243.      * If the validated value is neither of these, for example if the validator
  244.      * has been called with a plain value and constraint, this method returns
  245.      * null.
  246.      *
  247.      * @return MetadataInterface|null
  248.      */
  249.     public function getMetadata();
  251.     /**
  252.      * Returns the validation group that is currently being validated.
  253.      *
  254.      * @return string|null
  255.      */
  256.     public function getGroup();
  258.     /**
  259.      * Returns the class name of the current node.
  260.      *
  261.      * If the metadata of the current node does not implement
  262.      * {@link Mapping\ClassMetadataInterface} or if no metadata is available for the
  263.      * current node, this method returns null.
  264.      *
  265.      * @return string|null
  266.      */
  267.     public function getClassName();
  269.     /**
  270.      * Returns the property name of the current node.
  271.      *
  272.      * If the metadata of the current node does not implement
  273.      * {@link PropertyMetadataInterface} or if no metadata is available for the
  274.      * current node, this method returns null.
  275.      *
  276.      * @return string|null
  277.      */
  278.     public function getPropertyName();
  280.     /**
  281.      * Returns the property path to the value that the validator is currently
  282.      * validating.
  283.      *
  284.      * For example, take the following object graph:
  285.      *
  286.      * <pre>
  287.      * (Person)---($address: Address)---($street: string)
  288.      * </pre>
  289.      *
  290.      * When the <tt>Person</tt> instance is passed to the validator, the
  291.      * property path is initially empty. When the <tt>$address</tt> property
  292.      * of that person is validated, the property path is "address". When
  293.      * the <tt>$street</tt> property of the related <tt>Address</tt> instance
  294.      * is validated, the property path is "address.street".
  295.      *
  296.      * Properties of objects are prefixed with a dot in the property path.
  297.      * Indices of arrays or objects implementing the {@link \ArrayAccess}
  298.      * interface are enclosed in brackets. For example, if the property in
  299.      * the previous example is <tt>$addresses</tt> and contains an array
  300.      * of <tt>Address</tt> instance, the property path generated for the
  301.      * <tt>$street</tt> property of one of these addresses is for example
  302.      * "addresses[0].street".
  303.      *
  304.      * @param string $subPath Optional. The suffix appended to the current
  305.      *                        property path.
  306.      *
  307.      * @return string The current property path. The result may be an empty
  308.      *                string if the validator is currently validating the
  309.      *                root value of the validation graph.
  310.      */
  311.     public function getPropertyPath(string $subPath = '');
  312. }