You are here

abstract class Composite in Zircon Profile 8.0

Same name and namespace in other branches
  1. 8 vendor/symfony/validator/Constraints/Composite.php \Symfony\Component\Validator\Constraints\Composite

A constraint that is composed of other constraints.

You should never use the nested constraint instances anywhere else, because their groups are adapted when passed to the constructor of this class.

If you want to create your own composite constraint, extend this class and let {@link getCompositeOption()} return the name of the property which contains the nested constraints.

@since 2.6

@author Bernhard Schussek <bschussek@gmail.com>

Hierarchy

  • class \Symfony\Component\Validator\Constraint
    • class \Symfony\Component\Validator\Constraints\Composite

Expanded class hierarchy of Composite

1 file declares its use of Composite
CompositeTest.php in vendor/symfony/validator/Tests/Constraints/CompositeTest.php

File

vendor/symfony/validator/Constraints/Composite.php, line 31

Namespace

Symfony\Component\Validator\Constraints
View source
abstract class Composite extends Constraint {

  /**
   * {@inheritdoc}
   *
   * The groups of the composite and its nested constraints are made
   * consistent using the following strategy:
   *
   *   - If groups are passed explicitly to the composite constraint, but
   *     not to the nested constraints, the options of the composite
   *     constraint are copied to the nested constraints;
   *
   *   - If groups are passed explicitly to the nested constraints, but not
   *     to the composite constraint, the groups of all nested constraints
   *     are merged and used as groups for the composite constraint;
   *
   *   - If groups are passed explicitly to both the composite and its nested
   *     constraints, the groups of the nested constraints must be a subset
   *     of the groups of the composite constraint. If not, a
   *     {@link ConstraintDefinitionException} is thrown.
   *
   * All this is done in the constructor, because constraints can then be
   * cached. When constraints are loaded from the cache, no more group
   * checks need to be done.
   */
  public function __construct($options = null) {
    parent::__construct($options);
    $this
      ->initializeNestedConstraints();

    /* @var Constraint[] $nestedConstraints */
    $compositeOption = $this
      ->getCompositeOption();
    $nestedConstraints = $this->{$compositeOption};
    if (!is_array($nestedConstraints)) {
      $nestedConstraints = array(
        $nestedConstraints,
      );
    }
    foreach ($nestedConstraints as $constraint) {
      if (!$constraint instanceof Constraint) {
        throw new ConstraintDefinitionException(sprintf('The value %s is not an instance of Constraint in constraint %s', $constraint, get_class($this)));
      }
      if ($constraint instanceof Valid) {
        throw new ConstraintDefinitionException(sprintf('The constraint Valid cannot be nested inside constraint %s. You can only declare the Valid constraint directly on a field or method.', get_class($this)));
      }
    }
    if (!property_exists($this, 'groups')) {
      $mergedGroups = array();
      foreach ($nestedConstraints as $constraint) {
        foreach ($constraint->groups as $group) {
          $mergedGroups[$group] = true;
        }
      }
      $this->groups = array_keys($mergedGroups);
      $this->{$compositeOption} = $nestedConstraints;
      return;
    }
    foreach ($nestedConstraints as $constraint) {
      if (property_exists($constraint, 'groups')) {
        $excessGroups = array_diff($constraint->groups, $this->groups);
        if (count($excessGroups) > 0) {
          throw new ConstraintDefinitionException(sprintf('The group(s) "%s" passed to the constraint %s ' . 'should also be passed to its containing constraint %s', implode('", "', $excessGroups), get_class($constraint), get_class($this)));
        }
      }
      else {
        $constraint->groups = $this->groups;
      }
    }
    $this->{$compositeOption} = $nestedConstraints;
  }

  /**
   * {@inheritdoc}
   *
   * Implicit group names are forwarded to nested constraints.
   *
   * @param string $group
   */
  public function addImplicitGroupName($group) {
    parent::addImplicitGroupName($group);

    /** @var Constraint[] $nestedConstraints */
    $nestedConstraints = $this->{$this
      ->getCompositeOption()};
    foreach ($nestedConstraints as $constraint) {
      $constraint
        ->addImplicitGroupName($group);
    }
  }

  /**
   * Returns the name of the property that contains the nested constraints.
   *
   * @return string The property name
   */
  protected abstract function getCompositeOption();

  /**
   * Initializes the nested constraints.
   *
   * This method can be overwritten in subclasses to clean up the nested
   * constraints passed to the constructor.
   *
   * @see Collection::initializeNestedConstraints()
   */
  protected function initializeNestedConstraints() {
  }

}

Members

Namesort descending Modifiers Type Description Overrides
Composite::addImplicitGroupName public function Implicit group names are forwarded to nested constraints. Overrides Constraint::addImplicitGroupName
Composite::getCompositeOption abstract protected function Returns the name of the property that contains the nested constraints. 4
Composite::initializeNestedConstraints protected function Initializes the nested constraints. 1
Composite::__construct public function The groups of the composite and its nested constraints are made consistent using the following strategy: Overrides Constraint::__construct 1
Constraint::$errorNames protected static property Maps error codes to the names of their constants. 16
Constraint::$payload public property Domain-specific data attached to a constraint.
Constraint::CLASS_CONSTRAINT constant Marks a constraint that can be put onto classes.
Constraint::DEFAULT_GROUP constant The name of the group given to all constraints with no explicit group.
Constraint::getDefaultOption public function Returns the name of the default option. 18
Constraint::getErrorName public static function Returns the name of the given error code.
Constraint::getRequiredOptions public function Returns the name of the required options. 11
Constraint::getTargets public function Returns whether the constraint can be put onto classes, properties or both. 11
Constraint::PROPERTY_CONSTRAINT constant Marks a constraint that can be put onto properties.
Constraint::validatedBy public function Returns the name of the class that validates this constraint. 11
Constraint::__get public function Returns the value of a lazily initialized option. 1
Constraint::__set public function Sets the value of a lazily initialized option. 1
Constraint::__sleep public function Optimizes the serialized value to minimize storage space.