comparison vendor/symfony/validator/Constraint.php @ 4:a9cd425dd02b

Update, including to Drupal core 8.6.10

     const PROPERTY_CONSTRAINT = 'property';
 
     /**
      * Maps error codes to the names of their constants.
      */
-    protected static $errorNames = array();
+    protected static $errorNames = [];
 
     /**
      * Domain-specific data attached to a constraint.
      *
      * @var mixed

      * @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()
-            ));
+            throw new InvalidArgumentException(sprintf('The error code "%s" does not exist for constraint of type "%s".', $errorCode, \get_called_class()));
         }
 
         return static::$errorNames[$errorCode];
     }
 

      *                                       array, but getDefaultOption() returns
      *                                       null
      */
     public function __construct($options = null)
     {
-        $invalidOptions = array();
+        $invalidOptions = [];
         $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')) {
+        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)) {
+        if (\is_array($options)) {
             reset($options);
         }
-        if (is_array($options) && count($options) > 0 && is_string(key($options))) {
+        if ($options && \is_array($options) && \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) && 0 === count($options))) {
+        } elseif (null !== $options && !(\is_array($options) && 0 === \count($options))) {
             $option = $this->getDefaultOption();
 
             if (null === $option) {
-                throw new ConstraintDefinitionException(
-                    sprintf('No default option is configured for constraint %s', get_class($this))
-                );
+                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)
-            );
+        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.

             $this->groups = (array) $value;
 
             return;
         }
 
-        throw new InvalidOptionsException(sprintf('The option "%s" does not exist in constraint %s', $option, get_class($this)), array($option));
+        throw new InvalidOptionsException(sprintf('The option "%s" does not exist in constraint %s', $option, \get_class($this)), [$option]);
     }
 
     /**
      * Returns the value of a lazily initialized option.
      *

      * @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);
+            $this->groups = [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));
+        throw new InvalidOptionsException(sprintf('The option "%s" does not exist in constraint %s', $option, \get_class($this)), [$option]);
     }
 
     /**
      * @param string $option The option name
      *

      *
      * @param string $group
      */
     public function addImplicitGroupName($group)
     {
-        if (in_array(self::DEFAULT_GROUP, $this->groups) && !in_array($group, $this->groups)) {
+        if (\in_array(self::DEFAULT_GROUP, $this->groups) && !\in_array($group, $this->groups)) {
             $this->groups[] = $group;
         }
     }
 
     /**

      *
      * @see __construct()
      */
     public function getRequiredOptions()
     {
-        return array();
+        return [];
     }
 
     /**
      * Returns the name of the class that validates this constraint.
      *

      *
      * @return string
      */
     public function validatedBy()
     {
-        return get_class($this).'Validator';
+        return \get_class($this).'Validator';
     }
 
     /**
      * Returns whether the constraint can be put onto classes, properties or
      * both.

     /**
      * 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.
+     * @internal
      */
     public function __sleep()
     {
         // Initialize "groups" option if it is not set
         $this->groups;