class Validator

ValidatorTest.php in drupal/core/vendor/symfony/validator/Symfony/Component/Validator/Tests/ValidatorTest.php

ArgumentPluginBase::buildOptionsForm in drupal/core/modules/views/lib/Drupal/views/Plugin/views/argument/ArgumentPluginBase.php

Build the options form.

Constraint::validatedBy in drupal/core/vendor/symfony/validator/Symfony/Component/Validator/Constraint.php

Returns the name of the class that validates this constraint

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

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

class Validator implements ValidatorInterface {

  /**
   * @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 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 ' . $valueAsString . ' does not support properties.'));
    }
    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($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 ' . $valueAsString . ' does not support properties.'));
    }
    foreach ($this
      ->resolveGroups($groups) as $group) {
      if (!$metadata
        ->hasPropertyMetadata($property)) {
        continue;
      }
      foreach ($metadata
        ->getPropertyMetadata($property) as $propMeta) {
        $propMeta
          ->accept($visitor, $value, $group, $property);
      }
    }
    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,
    );
  }

}