Move into nested docroot

web/vendor/symfony/validator/Constraint.php

@@ -0,0 +1,308 @@
+<?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\ConstraintDefinitionException;
+use Symfony\Component\Validator\Exception\InvalidArgumentException;
+use Symfony\Component\Validator\Exception\InvalidOptionsException;
+use Symfony\Component\Validator\Exception\MissingOptionsException;
+
+/**
+ * Contains the properties of a constraint definition.
+ *
+ * A constraint can be defined on a class, a property or a getter method.
+ * The Constraint class encapsulates all the configuration required for
+ * validating this class, property or getter result successfully.
+ *
+ * Constraint instances are immutable and serializable.
+ *
+ * @property array $groups The groups that the constraint belongs to
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+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';
+
+    /**
+     * Maps error codes to the names of their constants.
+     *
+     * @var array
+     */
+    protected static $errorNames = array();
+
+    /**
+     * Domain-specific data attached to a constraint.
+     *
+     * @var mixed
+     */
+    public $payload;
+
+    /**
+     * Returns the name of the given error code.
+     *
+     * @param string $errorCode The error code
+     *
+     * @return string The name of the error code
+     *
+     * @throws InvalidArgumentException If the error code does not exist
+     */
+    public static function getErrorName($errorCode)
+    {
+        if (!isset(static::$errorNames[$errorCode])) {
+            throw new InvalidArgumentException(sprintf(
+                'The error code "%s" does not exist for constraint of type "%s".',
+                $errorCode,
+                get_called_class()
+            ));
+        }
+
+        return static::$errorNames[$errorCode];
+    }
+
+    /**
+     * 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
+     */
+    public function __construct($options = null)
+    {
+        $invalidOptions = array();
+        $missingOptions = array_flip((array) $this->getRequiredOptions());
+        $knownOptions = get_object_vars($this);
+
+        // The "groups" option is added to the object lazily
+        $knownOptions['groups'] = true;
+
+        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)) {
+            reset($options);
+        }
+        if (is_array($options) && count($options) > 0 && is_string(key($options))) {
+            foreach ($options as $option => $value) {
+                if (array_key_exists($option, $knownOptions)) {
+                    $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 (array_key_exists($option, $knownOptions)) {
+                $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)
+            );
+        }
+    }
+
+    /**
+     * Sets the value of a lazily initialized option.
+     *
+     * Corresponding properties are added to the object on first access. Hence
+     * this method will be called at most once per constraint instance and
+     * option name.
+     *
+     * @param string $option The option name
+     * @param mixed  $value  The value to set
+     *
+     * @throws InvalidOptionsException If an invalid option name is given
+     */
+    public function __set($option, $value)
+    {
+        if ('groups' === $option) {
+            $this->groups = (array) $value;
+
+            return;
+        }
+
+        throw new InvalidOptionsException(sprintf('The option "%s" does not exist in constraint %s', $option, get_class($this)), array($option));
+    }
+
+    /**
+     * Returns the value of a lazily initialized option.
+     *
+     * Corresponding properties are added to the object on first access. Hence
+     * this method will be called at most once per constraint instance and
+     * option name.
+     *
+     * @param string $option The option name
+     *
+     * @return mixed The value of the option
+     *
+     * @throws InvalidOptionsException If an invalid option name is given
+     *
+     * @internal This method should not be used or overwritten in userland code.
+     */
+    public function __get($option)
+    {
+        if ('groups' === $option) {
+            $this->groups = array(self::DEFAULT_GROUP);
+
+            return $this->groups;
+        }
+
+        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
+     */
+    public function addImplicitGroupName($group)
+    {
+        if (in_array(self::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()
+     */
+    public function getDefaultOption()
+    {
+    }
+
+    /**
+     * Returns the name of the required options.
+     *
+     * Override this method if you want to define required options.
+     *
+     * @return array
+     *
+     * @see __construct()
+     */
+    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
+     */
+    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
+     */
+    public function getTargets()
+    {
+        return self::PROPERTY_CONSTRAINT;
+    }
+
+    /**
+     * Optimizes the serialized value to minimize storage space.
+     *
+     * @return array The properties to serialize
+     *
+     * @internal This method may be replaced by an implementation of
+     *           {@link \Serializable} in the future. Please don't use or
+     *           overwrite it.
+     */
+    public function __sleep()
+    {
+        // Initialize "groups" option if it is not set
+        $this->groups;
+
+        return array_keys(get_object_vars($this));
+    }
+}