class ExecutionContext in Zircon Profile 8

Default implementation of {@link ExecutionContextInterface}.

This class is immutable by design.

@author Fabien Potencier <[e-mail]> @author Bernhard Schussek <[e-mail]>

Hierarchy

• class \Symfony\Component\Validator\ExecutionContext implements ExecutionContextInterface

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

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

Name	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.