diff -r 000000000000 -r 7f95f8617b0b vendor/symfony/src/Symfony/Component/Validator/Constraint.php --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/vendor/symfony/src/Symfony/Component/Validator/Constraint.php Sat Sep 24 15:40:41 2011 +0200 @@ -0,0 +1,220 @@ + + * + * 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 + * + * @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'])) { + $options = $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; + } + } + } else if (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; + } +}