class ExecutionContext in Drupal 10

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

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 23

Namespace

Drupal\Core\TypedData\Validation

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() : ConstraintViolationListInterface {
    return $this->violations;
  }

  /**
   * {@inheritdoc}
   */
  public function getValidator() : ValidatorInterface {
    return $this->validator;
  }

  /**
   * {@inheritdoc}
   */
  public function getRoot() : mixed {
    return $this->root;
  }

  /**
   * {@inheritdoc}
   */
  public function getValue() : mixed {
    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) : bool {
    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) : bool {
    return isset($this->validatedObjects[$cache_key][$group_hash]);
  }

  /**
   * {@inheritdoc}
   */
  public function markObjectAsInitialized($cache_key) {
    throw new \LogicException('\\Symfony\\Component\\Validator\\Context\\ExecutionContextInterface::markObjectAsInitialized is unsupported.');
  }

  /**
   * {@inheritdoc}
   */
  public function isObjectInitialized($cache_key) : bool {
    throw new \LogicException('\\Symfony\\Component\\Validator\\Context\\ExecutionContextInterface::isObjectInitialized is unsupported.');
  }

  /**
   * {@inheritdoc}
   */
  public function getMetadataFactory() {
    throw new \LogicException('Legacy validator API is unsupported.');
  }

}

Members

Name	Modifiers	Type	Description	Overrides
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.