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 <bschussek@gmail.com>
@api
Expanded class hierarchy of Constraint
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;
}
}
}
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 (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;
}
}
Name | Modifiers | Type | Description | Overrides |
---|---|---|---|---|
Constraint:: |
public | function | Unsupported operation. | |
Constraint:: |
public | function | Initializes the constraint with options. | 10 |
Constraint:: |
public | function | Returns the name of the class that validates this constraint | 2 |
Constraint:: |
constant | Marks a constraint that can be put onto properties | ||
Constraint:: |
public | function | Returns whether the constraint can be put onto classes, properties or both | 7 |
Constraint:: |
public | function | Returns the name of the required options | 10 |
Constraint:: |
public | function | Returns the name of the default option | 12 |
Constraint:: |
constant | The name of the group given to all constraints with no explicit group | ||
Constraint:: |
constant | Marks a constraint that can be put onto classes | ||
Constraint:: |
public | function | Adds the given group if this constraint is in the Default group | |
Constraint:: |
public | property |