class EntityType

Same name in this branch
  1. 10 core/lib/Drupal/Core/Entity/Annotation/EntityType.php \Drupal\Core\Entity\Annotation\EntityType
Same name in other branches
  1. 9 core/lib/Drupal/Core/Entity/EntityType.php \Drupal\Core\Entity\EntityType
  2. 9 core/lib/Drupal/Core/Entity/Annotation/EntityType.php \Drupal\Core\Entity\Annotation\EntityType
  3. 8.9.x core/lib/Drupal/Core/Entity/EntityType.php \Drupal\Core\Entity\EntityType
  4. 8.9.x core/lib/Drupal/Core/Entity/Annotation/EntityType.php \Drupal\Core\Entity\Annotation\EntityType
  5. 11.x core/lib/Drupal/Core/Entity/EntityType.php \Drupal\Core\Entity\EntityType
  6. 11.x core/lib/Drupal/Core/Entity/Annotation/EntityType.php \Drupal\Core\Entity\Annotation\EntityType

Provides an implementation of an entity type and its metadata.

Hierarchy

Expanded class hierarchy of EntityType

Related topics

12 files declare their use of EntityType
ConfigEntityType.php in core/lib/Drupal/Core/Config/Entity/ConfigEntityType.php
DefaultsSectionStorageTest.php in core/modules/layout_builder/tests/src/Unit/DefaultsSectionStorageTest.php
EntityContextDefinitionIsSatisfiedTest.php in core/tests/Drupal/Tests/Core/Plugin/Context/EntityContextDefinitionIsSatisfiedTest.php
EntityFormTest.php in core/tests/Drupal/Tests/Core/Entity/EntityFormTest.php
EntityTypeTest.php in core/tests/Drupal/Tests/Core/Entity/EntityTypeTest.php

... See full list

5 string references to 'EntityType'
EntityContextDefinition::getConstraintObjects in core/lib/Drupal/Core/Plugin/Context/EntityContextDefinition.php
Extracts an array of constraints for a context definition object.
EntityContextDefinitionIsSatisfiedTest::providerTestIsSatisfiedBy in core/tests/Drupal/Tests/Core/Plugin/Context/EntityContextDefinitionIsSatisfiedTest.php
Provides test data for ::testIsSatisfiedBy().
EntityDataDefinition::setEntityTypeId in core/lib/Drupal/Core/Entity/TypedData/EntityDataDefinition.php
Sets the entity type ID.
EntityReferenceItem::propertyDefinitions in core/lib/Drupal/Core/Field/Plugin/Field/FieldType/EntityReferenceItem.php
EntityStorageBaseTest::testLoadMultiple in core/tests/Drupal/Tests/Core/Entity/EntityStorageBaseTest.php
Test loadMultiple().

File

core/lib/Drupal/Core/Entity/EntityType.php, line 16

Namespace

Drupal\Core\Entity
View source
class EntityType extends PluginDefinition implements EntityTypeInterface {
    use DependencySerializationTrait;
    use StringTranslationTrait;
    
    /**
     * Indicates whether entities should be statically cached.
     *
     * @var bool
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $static_cache = TRUE;
    
    /**
     * Indicates whether the rendered output of entities should be cached.
     *
     * @var bool
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $render_cache = TRUE;
    
    /**
     * Indicates if the persistent cache of field data should be used.
     *
     * @var bool
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $persistent_cache = TRUE;
    
    /**
     * An array of entity keys.
     *
     * @var array
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $entity_keys = [];
    
    /**
     * The unique identifier of this entity type.
     *
     * @var string
     */
    protected $id;
    
    /**
     * The name of the original entity type class.
     *
     * This is only set if the class name is changed.
     *
     * @var string
     */
    protected $originalClass;
    
    /**
     * An array of handlers.
     *
     * @var array
     */
    protected $handlers = [];
    
    /**
     * The name of the default administrative permission.
     *
     * @var string
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $admin_permission;
    
    /**
     * The name of the collection permission.
     *
     * @var string
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $collection_permission;
    
    /**
     * The permission granularity level.
     *
     * The allowed values are respectively "entity_type" or "bundle".
     *
     * @var string
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $permission_granularity = 'entity_type';
    
    /**
     * Link templates using the URI template syntax.
     *
     * @var array
     */
    protected $links = [];
    
    /**
     * The name of the entity type which provides bundles.
     *
     * @var string
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $bundle_entity_type = NULL;
    
    /**
     * The name of the entity type for which bundles are provided.
     *
     * @var string|null
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $bundle_of = NULL;
    
    /**
     * The human-readable name of the entity bundles, e.g. Vocabulary.
     *
     * @var string|null
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $bundle_label = NULL;
    
    /**
     * The name of the entity type's base table.
     *
     * @var string|null
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $base_table = NULL;
    
    /**
     * The name of the entity type's revision data table.
     *
     * @var string|null
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $revision_data_table = NULL;
    
    /**
     * The name of the entity type's revision table.
     *
     * @var string|null
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $revision_table = NULL;
    
    /**
     * The name of the entity type's data table.
     *
     * @var string|null
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $data_table = NULL;
    
    /**
     * Indicates whether the entity data is internal.
     *
     * @var bool
     */
    protected $internal = FALSE;
    
    /**
     * Indicates whether entities of this type have multilingual support.
     *
     * @var bool
     */
    protected $translatable = FALSE;
    
    /**
     * Indicates whether the revision form fields should be added to the form.
     *
     * @var bool
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $show_revision_ui = FALSE;
    
    /**
     * The human-readable name of the type.
     *
     * @var string|\Drupal\Core\StringTranslation\TranslatableMarkup
     *
     * @see \Drupal\Core\Entity\EntityTypeInterface::getLabel()
     */
    protected $label = '';
    
    /**
     * The human-readable label for a collection of entities of the type.
     *
     * @var string|\Drupal\Core\StringTranslation\TranslatableMarkup
     *
     * @see \Drupal\Core\Entity\EntityTypeInterface::getCollectionLabel()
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $label_collection = '';
    
    /**
     * The indefinite singular name of the type.
     *
     * @var string|\Drupal\Core\StringTranslation\TranslatableMarkup
     *
     * @see \Drupal\Core\Entity\EntityTypeInterface::getSingularLabel()
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $label_singular = '';
    
    /**
     * The indefinite plural name of the type.
     *
     * @var string|\Drupal\Core\StringTranslation\TranslatableMarkup
     *
     * @see \Drupal\Core\Entity\EntityTypeInterface::getPluralLabel()
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $label_plural = '';
    
    /**
     * A definite singular/plural name of the type.
     *
     * Needed keys: "singular" and "plural". Can also have key: "context".
     * @code
     * [
     *    'singular' => '@count entity',
     *    'plural' => '@count entities',
     *    'context' => 'Entity context',
     * ]
     *
     * @var string[]
     *
     * @see \Drupal\Core\Entity\EntityTypeInterface::getCountLabel()
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $label_count = [];
    
    /**
     * A callable that can be used to provide the entity URI.
     *
     * @var callable|null
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $uri_callback = NULL;
    
    /**
     * The machine name of the entity type group.
     *
     * @var string
     *
     * @see self::getGroup()
     */
    protected $group;
    
    /**
     * The human-readable name of the entity type group.
     *
     * @var string|\Drupal\Core\StringTranslation\TranslatableMarkup
     *
     * @see \Drupal\Core\Entity\EntityTypeInterface::getGroupLabel()
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $group_label;
    
    /**
     * The route name used by field UI to attach its management pages.
     *
     * @var string
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $field_ui_base_route;
    
    /**
     * Indicates whether this entity type is commonly used as a reference target.
     *
     * This is used by the Entity reference field to promote an entity type in the
     * add new field select list in Field UI.
     *
     * @var bool
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $common_reference_target = FALSE;
    
    /**
     * The list cache contexts for this entity type.
     *
     * @var string[]
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $list_cache_contexts = [];
    
    /**
     * The list cache tags for this entity type.
     *
     * @var string[]
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $list_cache_tags = [];
    
    /**
     * Entity constraint definitions.
     *
     * @var array[]
     */
    protected $constraints = [];
    
    /**
     * Any additional properties and values.
     *
     * @var array
     */
    protected $additional = [];
    
    /**
     * Constructs a new EntityType.
     *
     * @param array $definition
     *   An array of values from the annotation.
     *
     * @throws \Drupal\Core\Entity\Exception\EntityTypeIdLengthException
     *   Thrown when attempting to instantiate an entity type with too long ID.
     */
    public function __construct($definition) {
        // Throw an exception if the entity type ID is longer than 32 characters.
        if (mb_strlen($definition['id']) > static::ID_MAX_LENGTH) {
            throw new EntityTypeIdLengthException('Attempt to create an entity type with an ID longer than ' . static::ID_MAX_LENGTH . " characters: {$definition['id']}.");
        }
        foreach ($definition as $property => $value) {
            $this->set($property, $value);
        }
        // Ensure defaults.
        $this->entity_keys += [
            'revision' => '',
            'bundle' => '',
            'langcode' => '',
            'default_langcode' => 'default_langcode',
            'revision_translation_affected' => 'revision_translation_affected',
        ];
        $this->handlers += [
            'access' => 'Drupal\\Core\\Entity\\EntityAccessControlHandler',
        ];
        if (isset($this->handlers['storage'])) {
            $this->checkStorageClass($this->handlers['storage']);
        }
        // Automatically add the "EntityChanged" constraint if the entity type
        // tracks the changed time.
        if ($this->entityClassImplements(EntityChangedInterface::class)) {
            $this->addConstraint('EntityChanged');
        }
        // Automatically add the "EntityUntranslatableFields" constraint if we have
        // an entity type supporting translatable fields and pending revisions.
        if ($this->entityClassImplements(ContentEntityInterface::class)) {
            $this->addConstraint('EntityUntranslatableFields');
        }
        // Ensure a default list cache tag is set.
        if (empty($this->list_cache_tags)) {
            $this->list_cache_tags = [
                $definition['id'] . '_list',
            ];
        }
    }
    
    /**
     * {@inheritdoc}
     */
    public function get($property) {
        if (property_exists($this, $property)) {
            $value = $this->{$property} ?? NULL;
        }
        else {
            $value = $this->additional[$property] ?? NULL;
        }
        return $value;
    }
    
    /**
     * {@inheritdoc}
     */
    public function set($property, $value) {
        if (property_exists($this, $property)) {
            $this->{$property} = $value;
        }
        else {
            $this->additional[$property] = $value;
        }
        return $this;
    }
    
    /**
     * {@inheritdoc}
     */
    public function isInternal() {
        return $this->internal;
    }
    
    /**
     * {@inheritdoc}
     */
    public function isStaticallyCacheable() {
        return $this->static_cache;
    }
    
    /**
     * {@inheritdoc}
     */
    public function isRenderCacheable() {
        return $this->render_cache;
    }
    
    /**
     * {@inheritdoc}
     */
    public function isPersistentlyCacheable() {
        return $this->persistent_cache;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getKeys() {
        return $this->entity_keys;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getKey($key) {
        $keys = $this->getKeys();
        return $keys[$key] ?? FALSE;
    }
    
    /**
     * {@inheritdoc}
     */
    public function hasKey($key) {
        $keys = $this->getKeys();
        return !empty($keys[$key]);
    }
    
    /**
     * {@inheritdoc}
     */
    public function getOriginalClass() {
        return $this->originalClass ?: $this->class;
    }
    
    /**
     * {@inheritdoc}
     */
    public function setClass($class) {
        if (!$this->originalClass && $this->class) {
            // If the original class is currently not set, set it to the current
            // class, assume that is the original class name.
            $this->originalClass = $this->class;
        }
        return parent::setClass($class);
    }
    
    /**
     * {@inheritdoc}
     */
    public function entityClassImplements($interface) {
        return is_subclass_of($this->getClass(), $interface);
    }
    
    /**
     * {@inheritdoc}
     */
    public function getHandlerClasses() {
        return $this->handlers;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getHandlerClass($handler_type, $nested = FALSE) {
        if ($this->hasHandlerClass($handler_type, $nested)) {
            $handlers = $this->getHandlerClasses();
            return $nested ? $handlers[$handler_type][$nested] : $handlers[$handler_type];
        }
        return NULL;
    }
    
    /**
     * {@inheritdoc}
     */
    public function setHandlerClass($handler_type, $value) {
        $this->handlers[$handler_type] = $value;
        return $this;
    }
    
    /**
     * {@inheritdoc}
     */
    public function hasHandlerClass($handler_type, $nested = FALSE) {
        $handlers = $this->getHandlerClasses();
        if (!isset($handlers[$handler_type]) || $nested && !isset($handlers[$handler_type][$nested])) {
            return FALSE;
        }
        $handler = $handlers[$handler_type];
        if ($nested) {
            $handler = $handler[$nested];
        }
        return class_exists($handler);
    }
    
    /**
     * {@inheritdoc}
     */
    public function getStorageClass() {
        return $this->getHandlerClass('storage');
    }
    
    /**
     * {@inheritdoc}
     */
    public function setStorageClass($class) {
        $this->checkStorageClass($class);
        $this->handlers['storage'] = $class;
        return $this;
    }
    
    /**
     * Checks that the provided class is compatible with the current entity type.
     *
     * @param string $class
     *   The class to check.
     */
    protected function checkStorageClass($class) {
        // Nothing to check by default.
    }
    
    /**
     * {@inheritdoc}
     */
    public function getFormClass($operation) {
        return $this->getHandlerClass('form', $operation);
    }
    
    /**
     * {@inheritdoc}
     */
    public function setFormClass($operation, $class) {
        $this->handlers['form'][$operation] = $class;
        return $this;
    }
    
    /**
     * {@inheritdoc}
     */
    public function hasFormClasses() {
        return !empty($this->handlers['form']);
    }
    
    /**
     * {@inheritdoc}
     */
    public function hasRouteProviders() {
        return !empty($this->handlers['route_provider']);
    }
    
    /**
     * {@inheritdoc}
     */
    public function getListBuilderClass() {
        return $this->getHandlerClass('list_builder');
    }
    
    /**
     * {@inheritdoc}
     */
    public function setListBuilderClass($class) {
        $this->handlers['list_builder'] = $class;
        return $this;
    }
    
    /**
     * {@inheritdoc}
     */
    public function hasListBuilderClass() {
        return $this->hasHandlerClass('list_builder');
    }
    
    /**
     * {@inheritdoc}
     */
    public function getViewBuilderClass() {
        return $this->getHandlerClass('view_builder');
    }
    
    /**
     * {@inheritdoc}
     */
    public function setViewBuilderClass($class) {
        $this->handlers['view_builder'] = $class;
        return $this;
    }
    
    /**
     * {@inheritdoc}
     */
    public function hasViewBuilderClass() {
        return $this->hasHandlerClass('view_builder');
    }
    
    /**
     * {@inheritdoc}
     */
    public function getRouteProviderClasses() {
        return !empty($this->handlers['route_provider']) ? $this->handlers['route_provider'] : [];
    }
    
    /**
     * {@inheritdoc}
     */
    public function getAccessControlClass() {
        return $this->getHandlerClass('access');
    }
    
    /**
     * {@inheritdoc}
     */
    public function setAccessClass($class) {
        $this->handlers['access'] = $class;
        return $this;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getAdminPermission() {
        return $this->admin_permission ?: FALSE;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getCollectionPermission() : ?string {
        return $this->collection_permission;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getPermissionGranularity() {
        return $this->permission_granularity;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getLinkTemplates() {
        return $this->links;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getLinkTemplate($key) {
        $links = $this->getLinkTemplates();
        return $links[$key] ?? FALSE;
    }
    
    /**
     * {@inheritdoc}
     */
    public function hasLinkTemplate($key) {
        $links = $this->getLinkTemplates();
        return isset($links[$key]);
    }
    
    /**
     * {@inheritdoc}
     */
    public function setLinkTemplate($key, $path) {
        if ($path[0] !== '/') {
            throw new \InvalidArgumentException('Link templates accepts paths, which have to start with a leading slash.');
        }
        $this->links[$key] = $path;
        return $this;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getBundleEntityType() {
        return $this->bundle_entity_type;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getBundleOf() {
        return $this->bundle_of;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getBundleLabel() {
        // If there is no bundle label defined, try to provide some sensible
        // fallbacks.
        if (!empty($this->bundle_label)) {
            return (string) $this->bundle_label;
        }
        elseif ($bundle_entity_type_id = $this->getBundleEntityType()) {
            return (string) \Drupal::entityTypeManager()->getDefinition($bundle_entity_type_id)
                ->getLabel();
        }
        return (string) new TranslatableMarkup('@type_label bundle', [
            '@type_label' => $this->getLabel(),
        ], [], $this->getStringTranslation());
    }
    
    /**
     * {@inheritdoc}
     */
    public function getBaseTable() {
        return $this->base_table;
    }
    
    /**
     * {@inheritdoc}
     */
    public function showRevisionUi() {
        return $this->isRevisionable() && $this->show_revision_ui;
    }
    
    /**
     * {@inheritdoc}
     */
    public function isTranslatable() {
        return !empty($this->translatable);
    }
    
    /**
     * {@inheritdoc}
     */
    public function isRevisionable() {
        // Entity types are revisionable if a revision key has been specified.
        return $this->hasKey('revision');
    }
    
    /**
     * {@inheritdoc}
     */
    public function getRevisionDataTable() {
        return $this->revision_data_table;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getRevisionTable() {
        return $this->revision_table;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getDataTable() {
        return $this->data_table;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getLabel() {
        return $this->label;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getCollectionLabel() {
        if (empty($this->label_collection)) {
            $label = $this->getLabel();
            $this->label_collection = new TranslatableMarkup('@label entities', [
                '@label' => $label,
            ], [], $this->getStringTranslation());
        }
        return $this->label_collection;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getSingularLabel() {
        if (empty($this->label_singular)) {
            $lowercase_label = mb_strtolower($this->getLabel());
            $this->label_singular = $lowercase_label;
        }
        return $this->label_singular;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getPluralLabel() {
        if (empty($this->label_plural)) {
            $lowercase_label = $this->getSingularLabel();
            $this->label_plural = new TranslatableMarkup('@label entities', [
                '@label' => $lowercase_label,
            ], [], $this->getStringTranslation());
        }
        return $this->label_plural;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getCountLabel($count) {
        if (empty($this->label_count)) {
            return $this->formatPlural($count, '@count @label', '@count @label entities', [
                '@label' => $this->getSingularLabel(),
            ], [
                'context' => 'Entity type label',
            ]);
        }
        $options = [];
        if (isset($this->label_count['context'])) {
            $options['context'] = $this->label_count['context'];
        }
        return $this->formatPlural($count, $this->label_count['singular'], $this->label_count['plural'], [], $options);
    }
    
    /**
     * {@inheritdoc}
     */
    public function getUriCallback() {
        return $this->uri_callback;
    }
    
    /**
     * {@inheritdoc}
     */
    public function setUriCallback($callback) {
        $this->uri_callback = $callback;
        return $this;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getGroup() {
        return $this->group;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getGroupLabel() {
        return !empty($this->group_label) ? $this->group_label : $this->t('Other', [], [
            'context' => 'Entity type group',
        ]);
    }
    
    /**
     * {@inheritdoc}
     */
    public function getListCacheContexts() {
        return $this->list_cache_contexts;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getListCacheTags() {
        return $this->list_cache_tags;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getConfigDependencyKey() {
        // Return 'content' for the default implementation as important distinction
        // is that dependencies on other configuration entities are hard
        // dependencies and have to exist before creating the dependent entity.
        return 'content';
    }
    
    /**
     * {@inheritdoc}
     */
    public function isCommonReferenceTarget() {
        return $this->common_reference_target;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getConstraints() {
        return $this->constraints;
    }
    
    /**
     * {@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 getBundleConfigDependency($bundle) {
        // If this entity type uses entities to manage its bundles then depend on
        // the bundle entity.
        if ($bundle_entity_type_id = $this->getBundleEntityType()) {
            if (!($bundle_entity = \Drupal::entityTypeManager()->getStorage($bundle_entity_type_id)
                ->load($bundle))) {
                throw new \LogicException(sprintf('Missing bundle entity, entity type %s, entity id %s.', $bundle_entity_type_id, $bundle));
            }
            $config_dependency = [
                'type' => 'config',
                'name' => $bundle_entity->getConfigDependencyName(),
            ];
        }
        else {
            // Depend on the provider of the entity type.
            $config_dependency = [
                'type' => 'module',
                'name' => $this->getProvider(),
            ];
        }
        return $config_dependency;
    }

}

Members

Title Sort descending Modifiers Object type Summary Overriden Title Overrides
DependencySerializationTrait::$_entityStorages protected property
DependencySerializationTrait::$_serviceIds protected property
DependencySerializationTrait::__sleep public function 1
DependencySerializationTrait::__wakeup public function 2
EntityType::$additional protected property Any additional properties and values.
EntityType::$admin_permission protected property
EntityType::$base_table protected property
EntityType::$bundle_entity_type protected property
EntityType::$bundle_label protected property
EntityType::$bundle_of protected property
EntityType::$collection_permission protected property
EntityType::$common_reference_target protected property
EntityType::$constraints protected property Entity constraint definitions.
EntityType::$data_table protected property
EntityType::$entity_keys protected property
EntityType::$field_ui_base_route protected property
EntityType::$group protected property The machine name of the entity type group.
EntityType::$group_label protected property
EntityType::$handlers protected property An array of handlers.
EntityType::$id protected property The unique identifier of this entity type. Overrides PluginDefinition::$id
EntityType::$internal protected property Indicates whether the entity data is internal.
EntityType::$label protected property The human-readable name of the type.
EntityType::$label_collection protected property
EntityType::$label_count protected property
EntityType::$label_plural protected property
EntityType::$label_singular protected property
EntityType::$links protected property Link templates using the URI template syntax.
EntityType::$list_cache_contexts protected property
EntityType::$list_cache_tags protected property
EntityType::$originalClass protected property The name of the original entity type class.
EntityType::$permission_granularity protected property
EntityType::$persistent_cache protected property
EntityType::$render_cache protected property
EntityType::$revision_data_table protected property
EntityType::$revision_table protected property
EntityType::$show_revision_ui protected property
EntityType::$static_cache protected property 1
EntityType::$translatable protected property Indicates whether entities of this type have multilingual support.
EntityType::$uri_callback protected property
EntityType::addConstraint public function Adds a validation constraint. Overrides EntityTypeInterface::addConstraint
EntityType::checkStorageClass protected function Checks that the provided class is compatible with the current entity type. 2
EntityType::entityClassImplements public function Indicates if the entity type class implements the given interface. Overrides EntityTypeInterface::entityClassImplements
EntityType::get public function Gets any arbitrary property. Overrides EntityTypeInterface::get
EntityType::getAccessControlClass public function Gets the access control class. Overrides EntityTypeInterface::getAccessControlClass
EntityType::getAdminPermission public function Gets the name of the default administrative permission. Overrides EntityTypeInterface::getAdminPermission
EntityType::getBaseTable public function Gets the name of the entity's base table. Overrides EntityTypeInterface::getBaseTable 1
EntityType::getBundleConfigDependency public function Gets the config dependency info for this entity, if any exists. Overrides EntityTypeInterface::getBundleConfigDependency
EntityType::getBundleEntityType public function Gets the name of the entity type which provides bundles. Overrides EntityTypeInterface::getBundleEntityType
EntityType::getBundleLabel public function Gets the label for the bundle. Overrides EntityTypeInterface::getBundleLabel
EntityType::getBundleOf public function Gets the entity type for which this entity provides bundles. Overrides EntityTypeInterface::getBundleOf
EntityType::getCollectionLabel public function Gets the uppercase plural form of the name of the entity type. Overrides EntityTypeInterface::getCollectionLabel
EntityType::getCollectionPermission public function Gets the name of the default collection permission. Overrides EntityTypeInterface::getCollectionPermission
EntityType::getConfigDependencyKey public function Gets the key that is used to store configuration dependencies. Overrides EntityTypeInterface::getConfigDependencyKey 2
EntityType::getConstraints public function Gets an array of validation constraints. Overrides EntityTypeInterface::getConstraints 1
EntityType::getCountLabel public function Gets the label's definite article form for use with a count of entities. Overrides EntityTypeInterface::getCountLabel
EntityType::getDataTable public function Gets the name of the entity's data table. Overrides EntityTypeInterface::getDataTable 1
EntityType::getFormClass public function Gets the form class for a specific operation. Overrides EntityTypeInterface::getFormClass
EntityType::getGroup public function Gets the machine name of the entity type group. Overrides EntityTypeInterface::getGroup
EntityType::getGroupLabel public function Gets the human-readable name of the entity type group. Overrides EntityTypeInterface::getGroupLabel
EntityType::getHandlerClass public function Overrides EntityTypeInterface::getHandlerClass
EntityType::getHandlerClasses public function Gets an array of handlers. Overrides EntityTypeInterface::getHandlerClasses
EntityType::getKey public function Gets a specific entity key. Overrides EntityTypeInterface::getKey
EntityType::getKeys public function Gets an array of entity keys. Overrides EntityTypeInterface::getKeys
EntityType::getLabel public function Gets the human-readable name of the entity type. Overrides EntityTypeInterface::getLabel
EntityType::getLinkTemplate public function Gets the link template for a given key. Overrides EntityTypeInterface::getLinkTemplate
EntityType::getLinkTemplates public function Gets the link templates using the URI template syntax. Overrides EntityTypeInterface::getLinkTemplates
EntityType::getListBuilderClass public function Gets the list class. Overrides EntityTypeInterface::getListBuilderClass
EntityType::getListCacheContexts public function The list cache contexts associated with this entity type. Overrides EntityTypeInterface::getListCacheContexts
EntityType::getListCacheTags public function The list cache tags associated with this entity type. Overrides EntityTypeInterface::getListCacheTags
EntityType::getOriginalClass public function Gets the name of the original entity type class. Overrides EntityTypeInterface::getOriginalClass
EntityType::getPermissionGranularity public function Gets the permission granularity level. Overrides EntityTypeInterface::getPermissionGranularity
EntityType::getPluralLabel public function Gets the indefinite plural form of the name of the entity type. Overrides EntityTypeInterface::getPluralLabel
EntityType::getRevisionDataTable public function Gets the name of the entity's revision data table. Overrides EntityTypeInterface::getRevisionDataTable 1
EntityType::getRevisionTable public function Gets the name of the entity's revision table. Overrides EntityTypeInterface::getRevisionTable 1
EntityType::getRouteProviderClasses public function Gets all the route provide handlers. Overrides EntityTypeInterface::getRouteProviderClasses
EntityType::getSingularLabel public function Gets the indefinite singular form of the name of the entity type. Overrides EntityTypeInterface::getSingularLabel
EntityType::getStorageClass public function Gets the storage class. Overrides EntityTypeInterface::getStorageClass
EntityType::getUriCallback public function Gets a callable that can be used to provide the entity URI. Overrides EntityTypeInterface::getUriCallback
EntityType::getViewBuilderClass public function Gets the view builder class. Overrides EntityTypeInterface::getViewBuilderClass
EntityType::hasFormClasses public function Indicates if this entity type has any forms. Overrides EntityTypeInterface::hasFormClasses
EntityType::hasHandlerClass public function Determines if there is a handler for a given type. Overrides EntityTypeInterface::hasHandlerClass
EntityType::hasKey public function Indicates if a given entity key exists. Overrides EntityTypeInterface::hasKey
EntityType::hasLinkTemplate public function Indicates if a link template exists for a given key. Overrides EntityTypeInterface::hasLinkTemplate
EntityType::hasListBuilderClass public function Indicates if this entity type has a list class. Overrides EntityTypeInterface::hasListBuilderClass
EntityType::hasRouteProviders public function Indicates if this entity type has any route provider. Overrides EntityTypeInterface::hasRouteProviders
EntityType::hasViewBuilderClass public function Indicates if this entity type has a view builder. Overrides EntityTypeInterface::hasViewBuilderClass
EntityType::isCommonReferenceTarget public function Indicates whether this entity type is commonly used as a reference target. Overrides EntityTypeInterface::isCommonReferenceTarget
EntityType::isInternal public function Indicates whether the entity data is internal. Overrides EntityTypeInterface::isInternal
EntityType::isPersistentlyCacheable public function Indicates if the persistent cache of field data should be used. Overrides EntityTypeInterface::isPersistentlyCacheable
EntityType::isRenderCacheable public function Indicates whether the rendered output of entities should be cached. Overrides EntityTypeInterface::isRenderCacheable
EntityType::isRevisionable public function Indicates whether entities of this type have revision support. Overrides EntityTypeInterface::isRevisionable
EntityType::isStaticallyCacheable public function Indicates whether entities should be statically cached. Overrides EntityTypeInterface::isStaticallyCacheable
EntityType::isTranslatable public function Indicates whether entities of this type have multilingual support. Overrides EntityTypeInterface::isTranslatable
EntityType::set public function Sets a value to an arbitrary property. Overrides EntityTypeInterface::set
EntityType::setAccessClass public function Sets the access control handler class. Overrides EntityTypeInterface::setAccessClass
EntityType::setClass public function Sets the class. Overrides PluginDefinition::setClass
EntityType::setConstraints public function Sets the array of validation constraints for the FieldItemList. Overrides EntityTypeInterface::setConstraints
EntityType::setFormClass public function Sets a form class for a specific operation. Overrides EntityTypeInterface::setFormClass
EntityType::setHandlerClass public function Sets the handlers for a given type. Overrides EntityTypeInterface::setHandlerClass
EntityType::setLinkTemplate public function Sets a single link template. Overrides EntityTypeInterface::setLinkTemplate
EntityType::setListBuilderClass public function Sets the list class. Overrides EntityTypeInterface::setListBuilderClass
EntityType::setStorageClass public function Sets the storage class. Overrides EntityTypeInterface::setStorageClass
EntityType::setUriCallback public function Sets a callable to use to provide the entity URI. Overrides EntityTypeInterface::setUriCallback
EntityType::setViewBuilderClass public function Gets the view builder class. Overrides EntityTypeInterface::setViewBuilderClass
EntityType::showRevisionUi public function Indicates whether the revision form fields should be added to the form. Overrides EntityTypeInterface::showRevisionUi
EntityType::__construct public function Constructs a new EntityType. 2
EntityTypeInterface::BUNDLE_MAX_LENGTH constant The maximum length of bundle name, in characters.
EntityTypeInterface::ID_MAX_LENGTH constant The maximum length of ID, in characters.
PluginDefinition::$class protected property A fully qualified class name.
PluginDefinition::$provider protected property The plugin provider.
PluginDefinition::getClass public function Gets the class. Overrides PluginDefinitionInterface::getClass 1
PluginDefinition::getProvider public function Gets the plugin provider. Overrides PluginDefinitionInterface::getProvider
PluginDefinition::id public function Gets the unique identifier of the plugin. Overrides PluginDefinitionInterface::id 1
StringTranslationTrait::$stringTranslation protected property The string translation service. 3
StringTranslationTrait::formatPlural protected function Formats a string containing a count of items.
StringTranslationTrait::getNumberOfPlurals protected function Returns the number of plurals supported by a given language.
StringTranslationTrait::getStringTranslation protected function Gets the string translation service.
StringTranslationTrait::setStringTranslation public function Sets the string translation service to use. 2
StringTranslationTrait::t protected function Translates a string to the current language or to a given language.

Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.