class ExecutionContext in Drupal 8

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

File

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

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 = []) {
    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() {
    return $this->data;
  }

  /**
   * {@inheritdoc}
   */
  public function getMetadata() {
    return $this->metadata;
  }

  /**
   * {@inheritdoc}
   */
  public function getGroup() {
    return Constraint::DEFAULT_GROUP;
  }

  /**
   * {@inheritdoc}
   */
  public function getClassName() {
    return get_class($this->data);
  }

  /**
   * {@inheritdoc}
   */
  public function getPropertyName() {
    return $this->data
      ->getName();
  }

  /**
   * {@inheritdoc}
   */
  public function getPropertyPath($sub_path = '') {
    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

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	Adds a violation at the current node of the validation graph.
ExecutionContext::addViolationAt	public	function	Adds a violation at the validation graph node with the given property path relative to the current property path.
ExecutionContext::buildViolation	public	function	Returns a builder for adding a violation with extended information.
ExecutionContext::getClassName	public	function	Returns the class name of the current node.
ExecutionContext::getGroup	public	function	Returns the validation group that is currently being validated.
ExecutionContext::getMetadata	public	function	Returns the metadata for the currently validated value.
ExecutionContext::getMetadataFactory	public	function	Returns the used metadata factory.
ExecutionContext::getObject	public	function	Returns the currently validated object.
ExecutionContext::getPropertyName	public	function	Returns the property name of the current node.
ExecutionContext::getPropertyPath	public	function	Returns the property path to the value that the validator is currently validating.
ExecutionContext::getRoot	public	function	Returns the value at which validation was started in the object graph.
ExecutionContext::getValidator	public	function	Returns the validator.
ExecutionContext::getValue	public	function	Returns the value that the validator is currently validating.
ExecutionContext::getViolations	public	function	Returns the violations generated by the validator so far.
ExecutionContext::isConstraintValidated	public	function	Returns whether a constraint was validated for an object.
ExecutionContext::isGroupValidated	public	function	Returns whether an object was validated in a specific validation group.
ExecutionContext::isObjectInitialized	public	function	Returns whether an object was initialized.
ExecutionContext::markConstraintAsValidated	public	function	Marks a constraint as validated for an object.
ExecutionContext::markGroupAsValidated	public	function	Marks an object as validated in a specific validation group.
ExecutionContext::markObjectAsInitialized	public	function	Marks that an object was initialized.
ExecutionContext::setConstraint	public	function	Sets the currently validated constraint.
ExecutionContext::setGroup	public	function	Sets the currently validated group.
ExecutionContext::setNode	public	function	Sets the currently validated value.
ExecutionContext::validate	public	function	Validates the given value within the scope of the current validation.
ExecutionContext::validateValue	public	function	Validates a value against a constraint.
ExecutionContext::__construct	public	function	Creates a new ExecutionContext.