class ExecutionContext

Same name in other branches
  1. 8.9.x core/lib/Drupal/Core/TypedData/Validation/ExecutionContext.php \Drupal\Core\TypedData\Validation\ExecutionContext
  2. 10 core/lib/Drupal/Core/TypedData/Validation/ExecutionContext.php \Drupal\Core\TypedData\Validation\ExecutionContext
  3. 10 core/lib/Drupal/Core/Validation/ExecutionContext.php \Drupal\Core\Validation\ExecutionContext
  4. 11.x core/lib/Drupal/Core/TypedData/Validation/ExecutionContext.php \Drupal\Core\TypedData\Validation\ExecutionContext
  5. 11.x core/lib/Drupal/Core/Validation/ExecutionContext.php \Drupal\Core\Validation\ExecutionContext

Defines an execution context class.

We do not use the context provided by Symfony as it is marked internal, so this class is pretty much the same, but has some code style changes as well as exceptions for methods we don't support.

Hierarchy

  • class \Drupal\Core\TypedData\Validation\ExecutionContext implements \Symfony\Component\Validator\Context\ExecutionContextInterface

Expanded class hierarchy of ExecutionContext

1 file declares its use of ExecutionContext
PrecedingConstraintAwareValidatorTrait.php in core/modules/ckeditor5/src/Plugin/Validation/Constraint/PrecedingConstraintAwareValidatorTrait.php

File

core/lib/Drupal/Core/TypedData/Validation/ExecutionContext.php, line 22

Namespace

Drupal\Core\TypedData\Validation
View source
class ExecutionContext implements ExecutionContextInterface {
    
    /**
     * @var \Symfony\Component\Validator\Validator\ValidatorInterface
     */
    protected $validator;
    
    /**
     * The root value of the validated object graph.
     *
     * @var mixed
     */
    protected $root;
    
    /**
     * @var \Drupal\Core\Validation\TranslatorInterface
     */
    protected $translator;
    
    /**
     * @var string
     */
    protected $translationDomain;
    
    /**
     * The violations generated in the current context.
     *
     * @var \Symfony\Component\Validator\ConstraintViolationList
     */
    protected $violations;
    
    /**
     * The currently validated value.
     *
     * @var mixed
     */
    protected $value;
    
    /**
     * The currently validated typed data object.
     *
     * @var \Drupal\Core\TypedData\TypedDataInterface
     */
    protected $data;
    
    /**
     * The property path leading to the current value.
     *
     * @var string
     */
    protected $propertyPath = '';
    
    /**
     * The current validation metadata.
     *
     * @var \Symfony\Component\Validator\Mapping\MetadataInterface|null
     */
    protected $metadata;
    
    /**
     * The currently validated group.
     *
     * @var string|null
     */
    protected $group;
    
    /**
     * The currently validated constraint.
     *
     * @var \Symfony\Component\Validator\Constraint|null
     */
    protected $constraint;
    
    /**
     * Stores which objects have been validated in which group.
     *
     * @var array
     */
    protected $validatedObjects = [];
    
    /**
     * Stores which class constraint has been validated for which object.
     *
     * @var array
     */
    protected $validatedConstraints = [];
    
    /**
     * Creates a new ExecutionContext.
     *
     * @param \Symfony\Component\Validator\Validator\ValidatorInterface $validator
     *   The validator.
     * @param mixed $root
     *   The root.
     * @param \Drupal\Core\Validation\TranslatorInterface $translator
     *   The translator.
     * @param string $translationDomain
     *   (optional) The translation domain.
     *
     * @internal Called by \Drupal\Core\TypedData\Validation\ExecutionContextFactory.
     *    Should not be used in user code.
     */
    public function __construct(ValidatorInterface $validator, $root, TranslatorInterface $translator, $translationDomain = NULL) {
        $this->validator = $validator;
        $this->root = $root;
        $this->translator = $translator;
        $this->translationDomain = $translationDomain;
        $this->violations = new ConstraintViolationList();
    }
    
    /**
     * {@inheritdoc}
     */
    public function setNode($value, $object, MetadataInterface $metadata = NULL, $propertyPath) {
        $this->value = $value;
        $this->data = $object;
        $this->metadata = $metadata;
        $this->propertyPath = (string) $propertyPath;
    }
    
    /**
     * {@inheritdoc}
     */
    public function setGroup($group) {
        $this->group = $group;
    }
    
    /**
     * {@inheritdoc}
     */
    public function setConstraint(Constraint $constraint) {
        $this->constraint = $constraint;
    }
    
    /**
     * {@inheritdoc}
     */
    public function addViolation($message, array $parameters = [], $invalidValue = NULL, $plural = NULL, $code = NULL) {
        // The parameters $invalidValue and following are ignored by the new
        // API, as they are not present in the new interface anymore.
        // You should use buildViolation() instead.
        if (func_num_args() > 2) {
            throw new \LogicException('Legacy validator API is unsupported.');
        }
        $this->violations
            ->add(new ConstraintViolation($this->translator
            ->trans($message, $parameters, $this->translationDomain), $message, $parameters, $this->root, $this->propertyPath, $this->value, NULL, NULL, $this->constraint));
    }
    
    /**
     * {@inheritdoc}
     */
    public function buildViolation($message, array $parameters = []) : ConstraintViolationBuilderInterface {
        return new ConstraintViolationBuilder($this->violations, $this->constraint, $message, $parameters, $this->root, $this->propertyPath, $this->value, $this->translator, $this->translationDomain);
    }
    
    /**
     * {@inheritdoc}
     */
    public function getViolations() {
        return $this->violations;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getValidator() {
        return $this->validator;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getRoot() {
        return $this->root;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getValue() {
        return $this->value;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getObject() : ?object {
        return $this->data;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getMetadata() : ?MetadataInterface {
        return $this->metadata;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getGroup() : ?string {
        return Constraint::DEFAULT_GROUP;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getClassName() : ?string {
        return get_class($this->data);
    }
    
    /**
     * {@inheritdoc}
     */
    public function getPropertyName() : ?string {
        return $this->data
            ->getName();
    }
    
    /**
     * {@inheritdoc}
     */
    public function getPropertyPath($sub_path = '') : string {
        return PropertyPath::append($this->propertyPath, $sub_path);
    }
    
    /**
     * {@inheritdoc}
     */
    public function addViolationAt($subPath, $message, array $parameters = [], $invalidValue = NULL, $plural = NULL, $code = NULL) {
        throw new \LogicException('Legacy validator API is unsupported.');
    }
    
    /**
     * {@inheritdoc}
     */
    public function validate($value, $subPath = '', $groups = NULL, $traverse = FALSE, $deep = FALSE) {
        throw new \LogicException('Legacy validator API is unsupported.');
    }
    
    /**
     * {@inheritdoc}
     */
    public function markConstraintAsValidated($cache_key, $constraint_hash) {
        $this->validatedConstraints[$cache_key . ':' . $constraint_hash] = TRUE;
    }
    
    /**
     * {@inheritdoc}
     */
    public function isConstraintValidated($cache_key, $constraint_hash) {
        return isset($this->validatedConstraints[$cache_key . ':' . $constraint_hash]);
    }
    
    /**
     * {@inheritdoc}
     */
    public function validateValue($value, $constraints, $subPath = '', $groups = NULL) {
        throw new \LogicException('Legacy validator API is unsupported.');
    }
    
    /**
     * {@inheritdoc}
     */
    public function markGroupAsValidated($cache_key, $group_hash) {
        $this->validatedObjects[$cache_key][$group_hash] = TRUE;
    }
    
    /**
     * {@inheritdoc}
     */
    public function isGroupValidated($cache_key, $group_hash) {
        return isset($this->validatedObjects[$cache_key][$group_hash]);
    }
    
    /**
     * {@inheritdoc}
     */
    public function markObjectAsInitialized($cache_key) {
        // Not supported, so nothing todo.
    }
    
    /**
     * {@inheritdoc}
     */
    public function isObjectInitialized($cache_key) {
        // Not supported, so nothing todo.
    }
    
    /**
     * {@inheritdoc}
     */
    public function getMetadataFactory() {
        throw new \LogicException('Legacy validator API is unsupported.');
    }

}

Members

Title Sort descending Modifiers Object type Summary
ExecutionContext::$constraint protected property The currently validated constraint.
ExecutionContext::$data protected property The currently validated typed data object.
ExecutionContext::$group protected property The currently validated group.
ExecutionContext::$metadata protected property The current validation metadata.
ExecutionContext::$propertyPath protected property The property path leading to the current value.
ExecutionContext::$root protected property The root value of the validated object graph.
ExecutionContext::$translationDomain protected property
ExecutionContext::$translator protected property
ExecutionContext::$validatedConstraints protected property Stores which class constraint has been validated for which object.
ExecutionContext::$validatedObjects protected property Stores which objects have been validated in which group.
ExecutionContext::$validator protected property
ExecutionContext::$value protected property The currently validated value.
ExecutionContext::$violations protected property The violations generated in the current context.
ExecutionContext::addViolation public function
ExecutionContext::addViolationAt public function
ExecutionContext::buildViolation public function
ExecutionContext::getClassName public function
ExecutionContext::getGroup public function
ExecutionContext::getMetadata public function
ExecutionContext::getMetadataFactory public function
ExecutionContext::getObject public function
ExecutionContext::getPropertyName public function
ExecutionContext::getPropertyPath public function
ExecutionContext::getRoot public function
ExecutionContext::getValidator public function
ExecutionContext::getValue public function
ExecutionContext::getViolations public function
ExecutionContext::isConstraintValidated public function
ExecutionContext::isGroupValidated public function
ExecutionContext::isObjectInitialized public function
ExecutionContext::markConstraintAsValidated public function
ExecutionContext::markGroupAsValidated public function
ExecutionContext::markObjectAsInitialized public function
ExecutionContext::setConstraint public function
ExecutionContext::setGroup public function
ExecutionContext::setNode public function
ExecutionContext::validate public function
ExecutionContext::validateValue public function
ExecutionContext::__construct public function Creates a new ExecutionContext.

Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.