abstract class Composite in Plug 7

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 <[e-mail]>

Hierarchy

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

1 file declares its use of Composite

CompositeTest.php in lib/Symfony/validator/Symfony/Component/Validator/Tests/Constraints/CompositeTest.php

File

lib/Symfony/validator/Symfony/Component/Validator/Constraints/Composite.php, line 30

Namespace

Symfony\Component\Validator\Constraints

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

Name	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.	15
Constraint::getErrorName	public static	function	Returns the name of the given error code.
Constraint::getRequiredOptions	public	function	Returns the name of the required options.	7
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.	1
Constraint::__get	public	function	Returns the value of a lazily initialized option.
Constraint::__set	public	function	Sets the value of a lazily initialized option.
Constraint::__sleep	public	function	Optimizes the serialized value to minimize storage space.