class Validator in Zircon Profile 8

Default implementation of {@link ValidatorInterface}.

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

Hierarchy

• class \Symfony\Component\Validator\Validator implements \Mapping\Factory\MetadataFactoryInterface, ValidatorInterface

Deprecated

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

1 file declares its use of Validator

LegacyValidatorTest.php in vendor/symfony/validator/Tests/LegacyValidatorTest.php

3 string references to 'Validator'

ArgumentPluginBase::buildOptionsForm in core/modules/views/src/Plugin/views/argument/ArgumentPluginBase.php

Provide a form to edit options for this plugin.

Constraint::validatedBy in vendor/symfony/validator/Constraint.php

Returns the name of the class that validates this constraint.

views.data_types.schema.yml in core/modules/views/config/schema/views.data_types.schema.yml

core/modules/views/config/schema/views.data_types.schema.yml

File

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

Namespace

Symfony\Component\Validator

class Validator implements ValidatorInterface, Mapping\Factory\MetadataFactoryInterface {

  /**
   * @var MetadataFactoryInterface
   */
  private $metadataFactory;

  /**
   * @var ConstraintValidatorFactoryInterface
   */
  private $validatorFactory;

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

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

  /**
   * @var array
   */
  private $objectInitializers;
  public function __construct(MetadataFactoryInterface $metadataFactory, ConstraintValidatorFactoryInterface $validatorFactory, TranslatorInterface $translator, $translationDomain = 'validators', array $objectInitializers = array()) {
    $this->metadataFactory = $metadataFactory;
    $this->validatorFactory = $validatorFactory;
    $this->translator = $translator;
    $this->translationDomain = $translationDomain;
    $this->objectInitializers = $objectInitializers;
  }

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

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

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

  /**
   * {@inheritdoc}
   */
  public function validate($value, $groups = null, $traverse = false, $deep = false) {
    $visitor = $this
      ->createVisitor($value);
    foreach ($this
      ->resolveGroups($groups) as $group) {
      $visitor
        ->validate($value, $group, '', $traverse, $deep);
    }
    return $visitor
      ->getViolations();
  }

  /**
   * {@inheritdoc}
   *
   * @throws ValidatorException If the metadata for the value does not support properties.
   */
  public function validateProperty($containingValue, $property, $groups = null) {
    $visitor = $this
      ->createVisitor($containingValue);
    $metadata = $this->metadataFactory
      ->getMetadataFor($containingValue);
    if (!$metadata instanceof PropertyMetadataContainerInterface) {
      $valueAsString = is_scalar($containingValue) ? '"' . $containingValue . '"' : 'the value of type ' . gettype($containingValue);
      throw new ValidatorException(sprintf('The metadata for %s does not support properties.', $valueAsString));
    }
    foreach ($this
      ->resolveGroups($groups) as $group) {
      if (!$metadata
        ->hasPropertyMetadata($property)) {
        continue;
      }
      foreach ($metadata
        ->getPropertyMetadata($property) as $propMeta) {
        $propMeta
          ->accept($visitor, $propMeta
          ->getPropertyValue($containingValue), $group, $property);
      }
    }
    return $visitor
      ->getViolations();
  }

  /**
   * {@inheritdoc}
   *
   * @throws ValidatorException If the metadata for the value does not support properties.
   */
  public function validatePropertyValue($containingValue, $property, $value, $groups = null) {
    $visitor = $this
      ->createVisitor(is_object($containingValue) ? $containingValue : $value);
    $metadata = $this->metadataFactory
      ->getMetadataFor($containingValue);
    if (!$metadata instanceof PropertyMetadataContainerInterface) {
      $valueAsString = is_scalar($containingValue) ? '"' . $containingValue . '"' : 'the value of type ' . gettype($containingValue);
      throw new ValidatorException(sprintf('The metadata for ' . $valueAsString . ' does not support properties.'));
    }

    // If $containingValue is passed as class name, take $value as root
    // and start the traversal with an empty property path
    $propertyPath = is_object($containingValue) ? $property : '';
    foreach ($this
      ->resolveGroups($groups) as $group) {
      if (!$metadata
        ->hasPropertyMetadata($property)) {
        continue;
      }
      foreach ($metadata
        ->getPropertyMetadata($property) as $propMeta) {
        $propMeta
          ->accept($visitor, $value, $group, $propertyPath);
      }
    }
    return $visitor
      ->getViolations();
  }

  /**
   * {@inheritdoc}
   */
  public function validateValue($value, $constraints, $groups = null) {
    $context = new ExecutionContext($this
      ->createVisitor($value), $this->translator, $this->translationDomain);
    $constraints = is_array($constraints) ? $constraints : array(
      $constraints,
    );
    foreach ($constraints as $constraint) {
      if ($constraint instanceof Valid) {

        // Why can't the Valid constraint be executed directly?
        //
        // It cannot be executed like regular other constraints, because regular
        // constraints are only executed *if they belong to the validated group*.
        // The Valid constraint, on the other hand, is always executed and propagates
        // the group to the cascaded object. The propagated group depends on
        //
        //  * Whether a group sequence is currently being executed. Then the default
        //    group is propagated.
        //
        //  * Otherwise the validated group is propagated.
        throw new ValidatorException(sprintf('The constraint %s cannot be validated. Use the method validate() instead.', get_class($constraint)));
      }
      $context
        ->validateValue($value, $constraint, '', $groups);
    }
    return $context
      ->getViolations();
  }

  /**
   * @param mixed $root
   *
   * @return ValidationVisitor
   */
  private function createVisitor($root) {
    return new ValidationVisitor($root, $this->metadataFactory, $this->validatorFactory, $this->translator, $this->translationDomain, $this->objectInitializers);
  }

  /**
   * @param null|string|string[] $groups
   *
   * @return string[]
   */
  private function resolveGroups($groups) {
    return $groups ? (array) $groups : array(
      Constraint::DEFAULT_GROUP,
    );
  }

}

Members

Name	Modifiers	Type	Description	Overrides
Validator::$metadataFactory	private	property
Validator::$objectInitializers	private	property
Validator::$translationDomain	private	property
Validator::$translator	private	property
Validator::$validatorFactory	private	property
Validator::createVisitor	private	function
Validator::getMetadataFactory	public	function	Returns the factory for metadata instances. Overrides ValidatorInterface::getMetadataFactory
Validator::getMetadataFor	public	function
Validator::hasMetadataFor	public	function
Validator::resolveGroups	private	function
Validator::validate	public	function	Validates a value. Overrides ValidatorInterface::validate
Validator::validateProperty	public	function	Overrides ValidatorInterface::validateProperty
Validator::validatePropertyValue	public	function	Overrides ValidatorInterface::validatePropertyValue
Validator::validateValue	public	function	Validates a value against a constraint or a list of constraints. Overrides ValidatorInterface::validateValue
Validator::__construct	public	function