FM / Validator

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

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

Name	Size	Mode	Actions
Constraints/	-	0755	rm
Exception/	-	0755	rm
Mapping/	-	0755	rm
Resources/	-	0755	rm
autoloader.php	339	0644	edit dl rm
ClassBasedInterface.php	572	0644	edit dl rm
Constraint.php	6797	0644	edit dl rm
ConstraintValidator.php	700	0644	edit dl rm
ConstraintValidatorFactory.php	2297	0644	edit dl rm
ConstraintValidatorFactoryInterface.php	775	0644	edit dl rm
ConstraintValidatorInterface.php	899	0644	edit dl rm
ConstraintViolation.php	4334	0644	edit dl rm
ConstraintViolationInterface.php	4353	0644	edit dl rm
ConstraintViolationList.php	3245	0644	edit dl rm
ConstraintViolationListInterface.php	2008	0644	edit dl rm
DefaultTranslator.php	5245	0644	edit dl rm
ExecutionContext.php	8495	0644	edit dl rm
ExecutionContextInterface.php	12355	0644	edit dl rm
GlobalExecutionContextInterface.php	1937	0644	edit dl rm
GroupSequenceProviderInterface.php	597	0644	edit dl rm
MetadataFactoryInterface.php	990	0644	edit dl rm
MetadataInterface.php	2891	0644	edit dl rm
ObjectInitializerInterface.php	817	0644	edit dl rm
PropertyMetadataContainerInterface.php	1209	0644	edit dl rm
PropertyMetadataInterface.php	1258	0644	edit dl rm
Validation.php	1098	0644	edit dl rm
ValidationVisitor.php	6322	0644	edit dl rm
ValidationVisitorInterface.php	3548	0644	edit dl rm
Validator.php	6681	0644	edit dl rm
ValidatorBuilder.php	10082	0644	edit dl rm
ValidatorBuilderInterface.php	5499	0644	edit dl rm
ValidatorInterface.php	3580	0644	edit dl rm

Edit: /opt/alt/php55/usr/share/pear/Symfony/Component/Validator/Constraint.php (6797B)

<?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\Exception\InvalidOptionsException;
use Symfony\Component\Validator\Exception\MissingOptionsException;
use Symfony\Component\Validator\Exception\ConstraintDefinitionException;

/**
 * Contains the properties of a constraint definition.
 *
 * A constraint can be defined on a class, an option or a getter method.
 * The Constraint class encapsulates all the configuration required for
 * validating this class, option or getter result successfully.
 *
 * Constraint instances are immutable and serializable.
 *
 * @author Bernhard Schussek <bschussek@gmail.com>
 *
 * @api
 */
abstract class Constraint
{
    /**
     * The name of the group given to all constraints with no explicit group
     * @var string
     */
    const DEFAULT_GROUP = 'Default';

/**
     * Marks a constraint that can be put onto classes
     * @var string
     */
    const CLASS_CONSTRAINT = 'class';

/**
     * Marks a constraint that can be put onto properties
     * @var string
     */
    const PROPERTY_CONSTRAINT = 'property';

/**
     * @var array
     */
    public $groups = array(self::DEFAULT_GROUP);

/**
     * Initializes the constraint with options.
     *
     * You should pass an associative array. The keys should be the names of
     * existing properties in this class. The values should be the value for these
     * properties.
     *
     * Alternatively you can override the method getDefaultOption() to return the
     * name of an existing property. If no associative array is passed, this
     * property is set instead.
     *
     * You can force that certain options are set by overriding
     * getRequiredOptions() to return the names of these options. If any
     * option is not set here, an exception is thrown.
     *
     * @param mixed $options The options (as associative array)
     *                       or the value for the default
     *                       option (any other type)
     *
     * @throws InvalidOptionsException       When you pass the names of non-existing
     *                                       options
     * @throws MissingOptionsException       When you don't pass any of the options
     *                                       returned by getRequiredOptions()
     * @throws ConstraintDefinitionException When you don't pass an associative
     *                                       array, but getDefaultOption() returns
     *                                       null
     *
     * @api
     */
    public function __construct($options = null)
    {
        $invalidOptions = array();
        $missingOptions = array_flip((array) $this->getRequiredOptions());

if (is_array($options) && count($options) >= 1 && isset($options['value']) && !property_exists($this, 'value')) {
            $options[$this->getDefaultOption()] = $options['value'];
            unset($options['value']);
        }

if (is_array($options) && count($options) > 0 && is_string(key($options))) {
            foreach ($options as $option => $value) {
                if (property_exists($this, $option)) {
                    $this->$option = $value;
                    unset($missingOptions[$option]);
                } else {
                    $invalidOptions[] = $option;
                }
            }
        } elseif (null !== $options && ! (is_array($options) && count($options) === 0)) {
            $option = $this->getDefaultOption();

if (null === $option) {
                throw new ConstraintDefinitionException(
                    sprintf('No default option is configured for constraint %s', get_class($this))
                );
            }

if (property_exists($this, $option)) {
                $this->$option = $options;
                unset($missingOptions[$option]);
            } else {
                $invalidOptions[] = $option;
            }
        }

if (count($invalidOptions) > 0) {
            throw new InvalidOptionsException(
                sprintf('The options "%s" do not exist in constraint %s', implode('", "', $invalidOptions), get_class($this)),
                $invalidOptions
            );
        }

if (count($missingOptions) > 0) {
            throw new MissingOptionsException(
                sprintf('The options "%s" must be set for constraint %s', implode('", "', array_keys($missingOptions)), get_class($this)),
                array_keys($missingOptions)
            );
        }

$this->groups = (array) $this->groups;
    }

/**
     * Unsupported operation.
     */
    public function __set($option, $value)
    {
        throw new InvalidOptionsException(sprintf('The option "%s" does not exist in constraint %s', $option, get_class($this)), array($option));
    }

/**
     * Adds the given group if this constraint is in the Default group
     *
     * @param string $group
     *
     * @api
     */
    public function addImplicitGroupName($group)
    {
        if (in_array(Constraint::DEFAULT_GROUP, $this->groups) && !in_array($group, $this->groups)) {
            $this->groups[] = $group;
        }
    }

/**
     * Returns the name of the default option
     *
     * Override this method to define a default option.
     *
     * @return string
     * @see __construct()
     *
     * @api
     */
    public function getDefaultOption()
    {
        return null;
    }

/**
     * Returns the name of the required options
     *
     * Override this method if you want to define required options.
     *
     * @return array
     * @see __construct()
     *
     * @api
     */
    public function getRequiredOptions()
    {
        return array();
    }

/**
     * Returns the name of the class that validates this constraint
     *
     * By default, this is the fully qualified name of the constraint class
     * suffixed with "Validator". You can override this method to change that
     * behaviour.
     *
     * @return string
     *
     * @api
     */
    public function validatedBy()
    {
        return get_class($this).'Validator';
    }

/**
     * Returns whether the constraint can be put onto classes, properties or
     * both
     *
     * This method should return one or more of the constants
     * Constraint::CLASS_CONSTRAINT and Constraint::PROPERTY_CONSTRAINT.
     *
     * @return string|array  One or more constant values
     *
     * @api
     */
    public function getTargets()
    {
        return self::PROPERTY_CONSTRAINT;
    }
}

cmd: