You are here

class ExecutionContext in Zircon Profile 8

Same name in this branch
  1. 8 vendor/symfony/validator/ExecutionContext.php \Symfony\Component\Validator\ExecutionContext
  2. 8 vendor/symfony/validator/Context/ExecutionContext.php \Symfony\Component\Validator\Context\ExecutionContext
  3. 8 core/lib/Drupal/Core/TypedData/Validation/ExecutionContext.php \Drupal\Core\TypedData\Validation\ExecutionContext
Same name and namespace in other branches
  1. 8.0 vendor/symfony/validator/ExecutionContext.php \Symfony\Component\Validator\ExecutionContext

Default implementation of {@link ExecutionContextInterface}.

This class is immutable by design.

@author Fabien Potencier <fabien@symfony.com> @author Bernhard Schussek <bschussek@gmail.com>

Hierarchy

Expanded class hierarchy of ExecutionContext

Deprecated

since version 2.5, to be removed in 3.0. Use {@link Context\ExecutionContext} instead.

1 file declares its use of ExecutionContext
LegacyExecutionContextTest.php in vendor/symfony/validator/Tests/LegacyExecutionContextTest.php

File

vendor/symfony/validator/ExecutionContext.php, line 29

Namespace

Symfony\Component\Validator
View source
class ExecutionContext implements ExecutionContextInterface {

  /**
   * @var GlobalExecutionContextInterface
   */
  private $globalContext;

  /**
   * @var TranslatorInterface
   */
  private $translator;

  /**
   * @var null|string
   */
  private $translationDomain;

  /**
   * @var MetadataInterface
   */
  private $metadata;

  /**
   * @var mixed
   */
  private $value;

  /**
   * @var string
   */
  private $group;

  /**
   * @var string
   */
  private $propertyPath;

  /**
   * Creates a new execution context.
   *
   * @param GlobalExecutionContextInterface $globalContext     The global context storing node-independent state.
   * @param TranslatorInterface             $translator        The translator for translating violation messages.
   * @param null|string                     $translationDomain The domain of the validation messages.
   * @param MetadataInterface               $metadata          The metadata of the validated node.
   * @param mixed                           $value             The value of the validated node.
   * @param string                          $group             The current validation group.
   * @param string                          $propertyPath      The property path to the current node.
   */
  public function __construct(GlobalExecutionContextInterface $globalContext, TranslatorInterface $translator, $translationDomain = null, MetadataInterface $metadata = null, $value = null, $group = null, $propertyPath = '') {
    if (null === $group) {
      $group = Constraint::DEFAULT_GROUP;
    }
    $this->globalContext = $globalContext;
    $this->translator = $translator;
    $this->translationDomain = $translationDomain;
    $this->metadata = $metadata;
    $this->value = $value;
    $this->propertyPath = $propertyPath;
    $this->group = $group;
  }

  /**
   * {@inheritdoc}
   */
  public function addViolation($message, array $params = array(), $invalidValue = null, $plural = null, $code = null) {
    if (null === $plural) {
      $translatedMessage = $this->translator
        ->trans($message, $params, $this->translationDomain);
    }
    else {
      try {
        $translatedMessage = $this->translator
          ->transChoice($message, $plural, $params, $this->translationDomain);
      } catch (\InvalidArgumentException $e) {
        $translatedMessage = $this->translator
          ->trans($message, $params, $this->translationDomain);
      }
    }
    $this->globalContext
      ->getViolations()
      ->add(new ConstraintViolation($translatedMessage, $message, $params, $this->globalContext
      ->getRoot(), $this->propertyPath, func_num_args() >= 3 ? $invalidValue : $this->value, $plural, $code));
  }

  /**
   * {@inheritdoc}
   */
  public function addViolationAt($subPath, $message, array $parameters = array(), $invalidValue = null, $plural = null, $code = null) {
    $this->globalContext
      ->getViolations()
      ->add(new ConstraintViolation(null === $plural ? $this->translator
      ->trans($message, $parameters, $this->translationDomain) : $this->translator
      ->transChoice($message, $plural, $parameters, $this->translationDomain), $message, $parameters, $this->globalContext
      ->getRoot(), $this
      ->getPropertyPath($subPath), func_num_args() >= 4 ? $invalidValue : $this->value, $plural, $code));
  }

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

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

  /**
   * {@inheritdoc}
   */
  public function getPropertyPath($subPath = '') {
    if ('' != $subPath && '' !== $this->propertyPath && '[' !== $subPath[0]) {
      return $this->propertyPath . '.' . $subPath;
    }
    return $this->propertyPath . $subPath;
  }

  /**
   * {@inheritdoc}
   */
  public function getClassName() {
    if ($this->metadata instanceof ClassBasedInterface) {
      return $this->metadata
        ->getClassName();
    }
  }

  /**
   * {@inheritdoc}
   */
  public function getPropertyName() {
    if ($this->metadata instanceof PropertyMetadataInterface) {
      return $this->metadata
        ->getPropertyName();
    }
  }

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

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

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

  /**
   * {@inheritdoc}
   */
  public function getMetadataFor($value) {
    return $this->globalContext
      ->getMetadataFactory()
      ->getMetadataFor($value);
  }

  /**
   * {@inheritdoc}
   */
  public function validate($value, $subPath = '', $groups = null, $traverse = false, $deep = false) {
    $propertyPath = $this
      ->getPropertyPath($subPath);
    foreach ($this
      ->resolveGroups($groups) as $group) {
      $this->globalContext
        ->getVisitor()
        ->validate($value, $group, $propertyPath, $traverse, $deep);
    }
  }

  /**
   * {@inheritdoc}
   */
  public function validateValue($value, $constraints, $subPath = '', $groups = null) {
    $constraints = is_array($constraints) ? $constraints : array(
      $constraints,
    );
    if (null === $groups && '' === $subPath) {
      $context = clone $this;
      $context->value = $value;
      $context
        ->executeConstraintValidators($value, $constraints);
      return;
    }
    $propertyPath = $this
      ->getPropertyPath($subPath);
    foreach ($this
      ->resolveGroups($groups) as $group) {
      $context = clone $this;
      $context->value = $value;
      $context->group = $group;
      $context->propertyPath = $propertyPath;
      $context
        ->executeConstraintValidators($value, $constraints);
    }
  }

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

  /**
   * Executes the validators of the given constraints for the given value.
   *
   * @param mixed        $value       The value to validate.
   * @param Constraint[] $constraints The constraints to match against.
   */
  private function executeConstraintValidators($value, array $constraints) {
    foreach ($constraints as $constraint) {
      $validator = $this->globalContext
        ->getValidatorFactory()
        ->getInstance($constraint);
      $validator
        ->initialize($this);
      $validator
        ->validate($value, $constraint);
    }
  }

  /**
   * Returns an array of group names.
   *
   * @param null|string|string[] $groups The groups to resolve. If a single string is
   *                                     passed, it is converted to an array. If null
   *                                     is passed, an array containing the current
   *                                     group of the context is returned.
   *
   * @return array An array of validation groups.
   */
  private function resolveGroups($groups) {
    return $groups ? (array) $groups : (array) $this->group;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
ExecutionContext::$globalContext private property
ExecutionContext::$group private property
ExecutionContext::$metadata private property
ExecutionContext::$propertyPath private property
ExecutionContext::$translationDomain private property
ExecutionContext::$translator private property
ExecutionContext::$value private property
ExecutionContext::addViolation public function Adds a violation at the current node of the validation graph. Overrides ExecutionContextInterface::addViolation
ExecutionContext::addViolationAt public function Adds a violation at the validation graph node with the given property path relative to the current property path. Overrides ExecutionContextInterface::addViolationAt
ExecutionContext::executeConstraintValidators private function Executes the validators of the given constraints for the given value.
ExecutionContext::getClassName public function Returns the class name of the current node. Overrides ExecutionContextInterface::getClassName
ExecutionContext::getGroup public function Returns the validation group that is currently being validated. Overrides ExecutionContextInterface::getGroup
ExecutionContext::getMetadata public function Returns the metadata for the currently validated value. Overrides ExecutionContextInterface::getMetadata
ExecutionContext::getMetadataFactory public function Returns the used metadata factory. Overrides ExecutionContextInterface::getMetadataFactory
ExecutionContext::getMetadataFor public function
ExecutionContext::getPropertyName public function Returns the property name of the current node. Overrides ExecutionContextInterface::getPropertyName
ExecutionContext::getPropertyPath public function Returns the property path to the value that the validator is currently validating. Overrides ExecutionContextInterface::getPropertyPath
ExecutionContext::getRoot public function Returns the value at which validation was started in the object graph. Overrides ExecutionContextInterface::getRoot
ExecutionContext::getValue public function Returns the value that the validator is currently validating. Overrides ExecutionContextInterface::getValue
ExecutionContext::getViolations public function Returns the violations generated by the validator so far. Overrides ExecutionContextInterface::getViolations
ExecutionContext::resolveGroups private function Returns an array of group names.
ExecutionContext::validate public function Validates the given value within the scope of the current validation. Overrides ExecutionContextInterface::validate
ExecutionContext::validateValue public function Validates a value against a constraint. Overrides ExecutionContextInterface::validateValue
ExecutionContext::__construct public function Creates a new execution context.