File Manager

X7ROOT File Manager

Current Path: /opt/alt/php54/usr/share/pear/Symfony/Component/Validator

opt / alt / php54 / usr / share / pear / Symfony / Component / Validator /

ðŸ“ ..
ðŸ“„ ClassBasedInterface.php(572 B)
ðŸ“„ Constraint.php(6.64 KB)
ðŸ“„ ConstraintValidator.php(700 B)
ðŸ“„ ConstraintValidatorFactory.php(2.24 KB)
ðŸ“„ ConstraintValidatorFactoryInterface.php(775 B)
ðŸ“„ ConstraintValidatorInterface.php(899 B)
ðŸ“„ ConstraintViolation.php(4.23 KB)
ðŸ“„ ConstraintViolationInterface.php(4.25 KB)
ðŸ“„ ConstraintViolationList.php(3.17 KB)
ðŸ“„ ConstraintViolationListInterface.php(1.96 KB)
ðŸ“ Constraints
ðŸ“„ DefaultTranslator.php(5.12 KB)
ðŸ“ Exception
ðŸ“„ ExecutionContext.php(8.3 KB)
ðŸ“„ ExecutionContextInterface.php(12.07 KB)
ðŸ“„ GlobalExecutionContextInterface.php(1.89 KB)
ðŸ“„ GroupSequenceProviderInterface.php(597 B)
ðŸ“ Mapping
ðŸ“„ MetadataFactoryInterface.php(990 B)
ðŸ“„ MetadataInterface.php(2.82 KB)
ðŸ“„ ObjectInitializerInterface.php(817 B)
ðŸ“„ PropertyMetadataContainerInterface.php(1.18 KB)
ðŸ“„ PropertyMetadataInterface.php(1.23 KB)
ðŸ“ Resources
ðŸ“„ Validation.php(1.07 KB)
ðŸ“„ ValidationVisitor.php(6.17 KB)
ðŸ“„ ValidationVisitorInterface.php(3.46 KB)
ðŸ“„ Validator.php(6.52 KB)
ðŸ“„ ValidatorBuilder.php(9.85 KB)
ðŸ“„ ValidatorBuilderInterface.php(5.37 KB)
ðŸ“„ ValidatorInterface.php(3.5 KB)
ðŸ“„ autoloader.php(339 B)

Editing: Validator.php

<?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Validator;

use Symfony\Component\Validator\Constraints\Valid;
use Symfony\Component\Validator\Exception\ValidatorException;
use Symfony\Component\Translation\TranslatorInterface;

/**
 * Default implementation of {@link ValidatorInterface}.
 *
 * @author Fabien Potencier <fabien@symfony.com>
 * @author Bernhard Schussek <bschussek@gmail.com>
 */
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 %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($containingValue);
        $metadata = $this->metadataFactory->getMetadataFor($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);
    }
}

X7ROOT File Manager

Editing: Validator.php

Upload File

Create Folder