class ContextDefinition
Same name in this branch
- 10 core/lib/Drupal/Core/Annotation/ContextDefinition.php \Drupal\Core\Annotation\ContextDefinition
Same name in other branches
- 9 core/lib/Drupal/Core/Annotation/ContextDefinition.php \Drupal\Core\Annotation\ContextDefinition
- 9 core/lib/Drupal/Core/Plugin/Context/ContextDefinition.php \Drupal\Core\Plugin\Context\ContextDefinition
- 8.9.x core/lib/Drupal/Core/Annotation/ContextDefinition.php \Drupal\Core\Annotation\ContextDefinition
- 8.9.x core/lib/Drupal/Core/Plugin/Context/ContextDefinition.php \Drupal\Core\Plugin\Context\ContextDefinition
- 11.x core/lib/Drupal/Core/Annotation/ContextDefinition.php \Drupal\Core\Annotation\ContextDefinition
- 11.x core/lib/Drupal/Core/Plugin/Context/ContextDefinition.php \Drupal\Core\Plugin\Context\ContextDefinition
Defines a class for context definitions.
Hierarchy
- class \Drupal\Core\Plugin\Context\ContextDefinition implements \Drupal\Core\Plugin\Context\ContextDefinitionInterface uses \Drupal\Core\DependencyInjection\DependencySerializationTrait, \Drupal\Core\TypedData\TypedDataTrait
Expanded class hierarchy of ContextDefinition
37 files declare their use of ContextDefinition
- ConditionTestNoExistingType.php in core/
modules/ system/ tests/ modules/ condition_test/ src/ Plugin/ Condition/ ConditionTestNoExistingType.php - ContextAwarePluginTraitTest.php in core/
tests/ Drupal/ KernelTests/ Core/ Plugin/ Context/ ContextAwarePluginTraitTest.php - ContextDefinitionIsSatisfiedTest.php in core/
tests/ Drupal/ Tests/ Core/ Plugin/ Context/ ContextDefinitionIsSatisfiedTest.php - ContextDefinitionTest.php in core/
tests/ Drupal/ KernelTests/ Core/ Plugin/ Annotation/ ContextDefinitionTest.php - ContextDefinitionTest.php in core/
tests/ Drupal/ Tests/ Core/ Plugin/ Context/ ContextDefinitionTest.php
File
-
core/
lib/ Drupal/ Core/ Plugin/ Context/ ContextDefinition.php, line 12
Namespace
Drupal\Core\Plugin\ContextView source
class ContextDefinition implements ContextDefinitionInterface {
use DependencySerializationTrait;
use TypedDataTrait;
/**
* The data type of the data.
*
* @var string
* The data type.
*/
protected $dataType;
/**
* The human-readable label.
*
* @var string
* The label.
*/
protected $label;
/**
* The human-readable description.
*
* @var string|null
* The description, or NULL if no description is available.
*/
protected $description;
/**
* Whether the data is multi-valued, i.e. a list of data items.
*
* @var bool
*/
protected $isMultiple = FALSE;
/**
* Determines whether a data value is required.
*
* @var bool
* Whether a data value is required.
*/
protected $isRequired = TRUE;
/**
* The default value.
*
* @var mixed
*/
protected $defaultValue;
/**
* An array of constraints.
*
* @var array[]
*/
protected $constraints = [];
/**
* Creates a new context definition.
*
* @param string $data_type
* The data type for which to create the context definition. Defaults to
* 'any'.
*
* @return static
* The created context definition object.
*/
public static function create($data_type = 'any') {
if (str_starts_with($data_type, 'entity:')) {
return new EntityContextDefinition($data_type);
}
return new static($data_type);
}
/**
* Constructs a new context definition object.
*
* @param string $data_type
* The required data type.
* @param string|null|\Stringable $label
* The label of this context definition for the UI.
* @param bool $required
* Whether the context definition is required.
* @param bool $multiple
* Whether the context definition is multivalue.
* @param string|null $description
* The description of this context definition for the UI.
* @param mixed $default_value
* The default value of this definition.
* @param array $constraints
* An array of constraints keyed by the constraint name and a value of an
* array constraint options or a NULL.
*/
public function __construct($data_type = 'any', $label = NULL, $required = TRUE, $multiple = FALSE, $description = NULL, $default_value = NULL, array $constraints = []) {
$this->dataType = $data_type;
$this->label = $label;
$this->isRequired = $required;
$this->isMultiple = $multiple;
$this->description = $description;
$this->defaultValue = $default_value;
foreach ($constraints as $constraint_name => $options) {
$this->addConstraint($constraint_name, $options);
}
assert(!str_starts_with($data_type, 'entity:') || $this instanceof EntityContextDefinition);
}
/**
* {@inheritdoc}
*/
public function getDataType() {
return $this->dataType;
}
/**
* {@inheritdoc}
*/
public function setDataType($data_type) {
$this->dataType = $data_type;
return $this;
}
/**
* {@inheritdoc}
*/
public function getLabel() {
return $this->label;
}
/**
* {@inheritdoc}
*/
public function setLabel($label) {
$this->label = $label;
return $this;
}
/**
* {@inheritdoc}
*/
public function getDescription() {
return $this->description;
}
/**
* {@inheritdoc}
*/
public function setDescription($description) {
$this->description = $description;
return $this;
}
/**
* {@inheritdoc}
*/
public function isMultiple() {
return $this->isMultiple;
}
/**
* {@inheritdoc}
*/
public function setMultiple($multiple = TRUE) {
$this->isMultiple = $multiple;
return $this;
}
/**
* {@inheritdoc}
*/
public function isRequired() {
return $this->isRequired;
}
/**
* {@inheritdoc}
*/
public function setRequired($required = TRUE) {
$this->isRequired = $required;
return $this;
}
/**
* {@inheritdoc}
*/
public function getDefaultValue() {
return $this->defaultValue;
}
/**
* {@inheritdoc}
*/
public function setDefaultValue($default_value) {
$this->defaultValue = $default_value;
return $this;
}
/**
* {@inheritdoc}
*/
public function getConstraints() {
// @todo Apply defaults.
return $this->constraints;
}
/**
* {@inheritdoc}
*/
public function getConstraint($constraint_name) {
$constraints = $this->getConstraints();
return $constraints[$constraint_name] ?? NULL;
}
/**
* {@inheritdoc}
*/
public function setConstraints(array $constraints) {
$this->constraints = $constraints;
return $this;
}
/**
* {@inheritdoc}
*/
public function addConstraint($constraint_name, $options = NULL) {
$this->constraints[$constraint_name] = $options;
return $this;
}
/**
* {@inheritdoc}
*/
public function getDataDefinition() {
if ($this->isMultiple()) {
$definition = $this->getTypedDataManager()
->createListDataDefinition($this->getDataType());
}
else {
$definition = $this->getTypedDataManager()
->createDataDefinition($this->getDataType());
}
if (!$definition) {
throw new \Exception("The data type '{$this->getDataType()}' is invalid");
}
$definition->setLabel($this->getLabel())
->setDescription($this->getDescription())
->setRequired($this->isRequired());
$constraints = $definition->getConstraints() + $this->getConstraints();
$definition->setConstraints($constraints);
return $definition;
}
/**
* Checks if this definition's data type matches that of the given context.
*
* @param \Drupal\Core\Plugin\Context\ContextInterface $context
* The context to test against.
*
* @return bool
* TRUE if the data types match, otherwise FALSE.
*/
protected function dataTypeMatches(ContextInterface $context) {
$this_type = $this->getDataType();
$that_type = $context->getContextDefinition()
->getDataType();
return $this_type === 'any' || $this_type === $that_type || str_starts_with($that_type, "{$this_type}:");
}
/**
* {@inheritdoc}
*/
public function isSatisfiedBy(ContextInterface $context) {
$definition = $context->getContextDefinition();
if (!$this->dataTypeMatches($context)) {
return FALSE;
}
// Get the value for this context, either directly if possible or by
// introspecting the definition.
if ($context->hasContextValue()) {
$values = [
$context->getContextData(),
];
}
elseif ($definition instanceof self) {
$values = $definition->getSampleValues();
}
else {
$values = [];
}
$validator = $this->getTypedDataManager()
->getValidator();
foreach ($values as $value) {
$constraints = array_values($this->getConstraintObjects());
if ($definition->isMultiple()) {
$violations = new ConstraintViolationList();
foreach ($value as $item) {
$violations->addAll($validator->validate($item, $constraints));
}
}
else {
$violations = $validator->validate($value, $constraints);
}
foreach ($violations as $delta => $violation) {
// Remove any violation that does not correspond to the constraints.
if (!in_array($violation->getConstraint(), $constraints)) {
$violations->remove($delta);
}
}
// If a value has no violations then the requirement is satisfied.
if (!$violations->count()) {
return TRUE;
}
}
return FALSE;
}
/**
* Returns typed data objects representing this context definition.
*
* This should return as many objects as needed to reflect the variations of
* the constraints it supports.
*
* @yield \Drupal\Core\TypedData\TypedDataInterface
* The set of typed data object.
*/
protected function getSampleValues() {
(yield $this->getTypedDataManager()
->create($this->getDataDefinition()));
}
/**
* Extracts an array of constraints for a context definition object.
*
* @return \Symfony\Component\Validator\Constraint[]
* A list of applied constraints for the context definition.
*/
protected function getConstraintObjects() {
$constraint_definitions = $this->getConstraints();
$validation_constraint_manager = $this->getTypedDataManager()
->getValidationConstraintManager();
$constraints = [];
foreach ($constraint_definitions as $constraint_name => $constraint_definition) {
$constraints[$constraint_name] = $validation_constraint_manager->create($constraint_name, $constraint_definition);
}
return $constraints;
}
}
Members
Title Sort descending | Modifiers | Object type | Summary | Overriden Title | Overrides |
---|---|---|---|---|---|
ContextDefinition::$constraints | protected | property | An array of constraints. | ||
ContextDefinition::$dataType | protected | property | The data type of the data. | ||
ContextDefinition::$defaultValue | protected | property | The default value. | ||
ContextDefinition::$description | protected | property | The human-readable description. | ||
ContextDefinition::$isMultiple | protected | property | Whether the data is multi-valued, i.e. a list of data items. | ||
ContextDefinition::$isRequired | protected | property | Determines whether a data value is required. | ||
ContextDefinition::$label | protected | property | The human-readable label. | ||
ContextDefinition::addConstraint | public | function | Adds a validation constraint. | Overrides ContextDefinitionInterface::addConstraint | |
ContextDefinition::create | public static | function | Creates a new context definition. | ||
ContextDefinition::dataTypeMatches | protected | function | Checks if this definition's data type matches that of the given context. | ||
ContextDefinition::getConstraint | public | function | Gets a validation constraint. | Overrides ContextDefinitionInterface::getConstraint | |
ContextDefinition::getConstraintObjects | protected | function | Extracts an array of constraints for a context definition object. | 1 | |
ContextDefinition::getConstraints | public | function | Gets an array of validation constraints. | Overrides ContextDefinitionInterface::getConstraints | |
ContextDefinition::getDataDefinition | public | function | Returns the data definition of the defined context. | Overrides ContextDefinitionInterface::getDataDefinition | |
ContextDefinition::getDataType | public | function | Gets the data type needed by the context. | Overrides ContextDefinitionInterface::getDataType | |
ContextDefinition::getDefaultValue | public | function | Gets the default value for this context definition. | Overrides ContextDefinitionInterface::getDefaultValue | |
ContextDefinition::getDescription | public | function | Gets a human readable description. | Overrides ContextDefinitionInterface::getDescription | |
ContextDefinition::getLabel | public | function | Gets a human readable label. | Overrides ContextDefinitionInterface::getLabel | |
ContextDefinition::getSampleValues | protected | function | Returns typed data objects representing this context definition. | 1 | |
ContextDefinition::isMultiple | public | function | Determines whether the data is multi-valued, i.e. a list of data items. | Overrides ContextDefinitionInterface::isMultiple | |
ContextDefinition::isRequired | public | function | Determines whether the context is required. | Overrides ContextDefinitionInterface::isRequired | |
ContextDefinition::isSatisfiedBy | public | function | Determines if this definition is satisfied by a context object. | Overrides ContextDefinitionInterface::isSatisfiedBy | |
ContextDefinition::setConstraints | public | function | Sets the array of validation constraints. | Overrides ContextDefinitionInterface::setConstraints | |
ContextDefinition::setDataType | public | function | Sets the data type needed by the context. | Overrides ContextDefinitionInterface::setDataType | |
ContextDefinition::setDefaultValue | public | function | Sets the default data value. | Overrides ContextDefinitionInterface::setDefaultValue | |
ContextDefinition::setDescription | public | function | Sets the human readable description. | Overrides ContextDefinitionInterface::setDescription | |
ContextDefinition::setLabel | public | function | Sets the human readable label. | Overrides ContextDefinitionInterface::setLabel | |
ContextDefinition::setMultiple | public | function | Sets whether the data is multi-valued. | Overrides ContextDefinitionInterface::setMultiple | |
ContextDefinition::setRequired | public | function | Sets whether the data is required. | Overrides ContextDefinitionInterface::setRequired | |
ContextDefinition::__construct | public | function | Constructs a new context definition object. | 1 | |
DependencySerializationTrait::$_entityStorages | protected | property | |||
DependencySerializationTrait::$_serviceIds | protected | property | |||
DependencySerializationTrait::__sleep | public | function | 1 | ||
DependencySerializationTrait::__wakeup | public | function | 2 | ||
TypedDataTrait::$typedDataManager | protected | property | The typed data manager used for creating the data types. | ||
TypedDataTrait::getTypedDataManager | public | function | Gets the typed data manager. | 2 | |
TypedDataTrait::setTypedDataManager | public | function | Sets the typed data manager. | 2 |
Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.