class ConfigEntityBase

Same name in other branches
  1. 9 core/lib/Drupal/Core/Config/Entity/ConfigEntityBase.php \Drupal\Core\Config\Entity\ConfigEntityBase
  2. 8.9.x core/lib/Drupal/Core/Config/Entity/ConfigEntityBase.php \Drupal\Core\Config\Entity\ConfigEntityBase
  3. 11.x core/lib/Drupal/Core/Config/Entity/ConfigEntityBase.php \Drupal\Core\Config\Entity\ConfigEntityBase

Defines a base configuration entity class.

Hierarchy

Expanded class hierarchy of ConfigEntityBase

Related topics

28 files declare their use of ConfigEntityBase
Action.php in core/modules/system/src/Entity/Action.php
Block.php in core/modules/block/src/Entity/Block.php
ConfigEntityBaseUnitTest.php in core/tests/Drupal/Tests/Core/Config/Entity/ConfigEntityBaseUnitTest.php
ConfigEntityBaseWithPluginCollections.php in core/tests/Drupal/Tests/Core/Config/Entity/Fixtures/ConfigEntityBaseWithPluginCollections.php
ConfigEntityStorageTest.php in core/tests/Drupal/Tests/Core/Config/Entity/ConfigEntityStorageTest.php

... See full list

File

core/lib/Drupal/Core/Config/Entity/ConfigEntityBase.php, line 23

Namespace

Drupal\Core\Config\Entity
View source
abstract class ConfigEntityBase extends EntityBase implements ConfigEntityInterface {
    use PluginDependencyTrait {
        addDependency as addDependencyTrait;
    }
    use SynchronizableEntityTrait;
    
    /**
     * The original ID of the configuration entity.
     *
     * The ID of a configuration entity is a unique string (machine name). When a
     * configuration entity is updated and its machine name is renamed, the
     * original ID needs to be known.
     *
     * @var string
     */
    protected $originalId;
    
    /**
     * The enabled/disabled status of the configuration entity.
     *
     * @var bool
     */
    protected $status = TRUE;
    
    /**
     * The UUID for this entity.
     *
     * @var string
     */
    protected $uuid;
    
    /**
     * Whether the config is being deleted by the uninstall process.
     *
     * @var bool
     */
    private $isUninstalling = FALSE;
    
    /**
     * The language code of the entity's default language.
     *
     * Assumed to be English by default. ConfigEntityStorage will set an
     * appropriate language when creating new entities. This default applies to
     * imported default configuration where the language code is missing. Those
     * should be assumed to be English. All configuration entities support third
     * party settings, so even configuration entities that do not directly
     * store settings involving text in a human language may have such third
     * party settings attached. This means configuration entities should be in one
     * of the configured languages or the built-in English.
     *
     * @var string
     */
    protected $langcode = 'en';
    
    /**
     * Third party entity settings.
     *
     * An array of key/value pairs keyed by provider.
     *
     * @var array
     */
    // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $third_party_settings = [];
    
    /**
     * Information maintained by Drupal core about configuration.
     *
     * Keys:
     * - default_config_hash: A hash calculated by the config.installer service
     *   and added during installation.
     *
     * @var array
     */
    // phpcs:ignore Drupal.Classes.PropertyDeclaration, Drupal.NamingConventions.ValidVariableName.LowerCamelName
    protected $_core = [];
    
    /**
     * Trust supplied data and not use configuration schema on save.
     *
     * @var bool
     */
    protected $trustedData = FALSE;
    
    /**
     * {@inheritdoc}
     */
    public function __construct(array $values, $entity_type) {
        parent::__construct($values, $entity_type);
        // Backup the original ID, if any.
        // Configuration entity IDs are strings, and '0' is a valid ID.
        $original_id = $this->id();
        if ($original_id !== NULL && $original_id !== '') {
            $this->setOriginalId($original_id);
        }
    }
    
    /**
     * {@inheritdoc}
     */
    public function getOriginalId() {
        return $this->originalId;
    }
    
    /**
     * {@inheritdoc}
     */
    public function setOriginalId($id) {
        // Do not call the parent method since that would mark this entity as no
        // longer new. Unlike content entities, new configuration entities have an
        // ID.
        // @todo https://www.drupal.org/node/2478811 Document the entity life cycle
        //   and the differences between config and content.
        $this->originalId = $id;
        return $this;
    }
    
    /**
     * Overrides Entity::isNew().
     *
     * EntityInterface::enforceIsNew() is only supported for newly created
     * configuration entities but has no effect after saving, since each
     * configuration entity is unique.
     */
    public function isNew() {
        return !empty($this->enforceIsNew);
    }
    
    /**
     * {@inheritdoc}
     */
    public function get($property_name) {
        return $this->{$property_name} ?? NULL;
    }
    
    /**
     * {@inheritdoc}
     */
    public function set($property_name, $value) {
        if ($this instanceof EntityWithPluginCollectionInterface && !$this->isSyncing()) {
            $plugin_collections = $this->getPluginCollections();
            if (isset($plugin_collections[$property_name])) {
                // If external code updates the settings, pass it along to the plugin.
                $plugin_collections[$property_name]->setConfiguration($value);
            }
        }
        $this->{$property_name} = $value;
        return $this;
    }
    
    /**
     * {@inheritdoc}
     */
    public function enable() {
        return $this->setStatus(TRUE);
    }
    
    /**
     * {@inheritdoc}
     */
    public function disable() {
        return $this->setStatus(FALSE);
    }
    
    /**
     * {@inheritdoc}
     */
    public function setStatus($status) {
        $this->status = (bool) $status;
        return $this;
    }
    
    /**
     * {@inheritdoc}
     */
    public function status() {
        return !empty($this->status);
    }
    
    /**
     * {@inheritdoc}
     */
    public function setUninstalling($uninstalling) {
        $this->isUninstalling = $uninstalling;
    }
    
    /**
     * {@inheritdoc}
     */
    public function isUninstalling() {
        return $this->isUninstalling;
    }
    
    /**
     * {@inheritdoc}
     */
    public function createDuplicate() {
        $duplicate = parent::createDuplicate();
        // Prevent the new duplicate from being misinterpreted as a rename.
        $duplicate->setOriginalId(NULL);
        return $duplicate;
    }
    
    /**
     * Helper callback for uasort() to sort configuration entities by weight and label.
     */
    public static function sort(ConfigEntityInterface $a, ConfigEntityInterface $b) {
        $a_weight = $a->weight ?? 0;
        $b_weight = $b->weight ?? 0;
        if ($a_weight == $b_weight) {
            $a_label = $a->label() ?? '';
            $b_label = $b->label() ?? '';
            return strnatcasecmp($a_label, $b_label);
        }
        return $a_weight <=> $b_weight;
    }
    
    /**
     * {@inheritdoc}
     */
    public function toArray() {
        $properties = [];
        
        /** @var \Drupal\Core\Config\Entity\ConfigEntityTypeInterface $entity_type */
        $entity_type = $this->getEntityType();
        $id_key = $entity_type->getKey('id');
        $property_names = $entity_type->getPropertiesToExport($this->id());
        if (empty($property_names)) {
            throw new SchemaIncompleteException(sprintf("Entity type '%s' is missing 'config_export' definition in its annotation", $entity_type->getClass()));
        }
        foreach ($property_names as $property_name => $export_name) {
            // Special handling for IDs so that computed compound IDs work.
            // @see \Drupal\Core\Entity\EntityDisplayBase::id()
            if ($property_name == $id_key) {
                $properties[$export_name] = $this->id();
            }
            else {
                $properties[$export_name] = $this->get($property_name);
            }
        }
        if (empty($this->third_party_settings)) {
            unset($properties['third_party_settings']);
        }
        if (empty($this->_core)) {
            unset($properties['_core']);
        }
        return $properties;
    }
    
    /**
     * Gets the typed config manager.
     *
     * @return \Drupal\Core\Config\TypedConfigManagerInterface
     */
    protected function getTypedConfig() {
        return \Drupal::service('config.typed');
    }
    
    /**
     * {@inheritdoc}
     */
    public function preSave(EntityStorageInterface $storage) {
        
        /** @var \Drupal\Core\Config\Entity\ConfigEntityStorageInterface $storage */
        parent::preSave($storage);
        if ($this instanceof EntityWithPluginCollectionInterface && !$this->isSyncing()) {
            // Any changes to the plugin configuration must be saved to the entity's
            // copy as well.
            foreach ($this->getPluginCollections() as $plugin_config_key => $plugin_collection) {
                $this->set($plugin_config_key, $plugin_collection->getConfiguration());
            }
        }
        // Ensure this entity's UUID does not exist with a different ID, regardless
        // of whether it's new or updated.
        $matching_entities = $storage->getQuery()
            ->condition('uuid', $this->uuid())
            ->execute();
        $matched_entity = reset($matching_entities);
        if (!empty($matched_entity) && $matched_entity != $this->id() && $matched_entity != $this->getOriginalId()) {
            throw new ConfigDuplicateUUIDException("Attempt to save a configuration entity '{$this->id()}' with UUID '{$this->uuid()}' when this UUID is already used for '{$matched_entity}'");
        }
        // If this entity is not new, load the original entity for comparison.
        if (!$this->isNew()) {
            $original = $storage->loadUnchanged($this->getOriginalId());
            // Ensure that the UUID cannot be changed for an existing entity.
            if ($original && $original->uuid() != $this->uuid()) {
                throw new ConfigDuplicateUUIDException("Attempt to save a configuration entity '{$this->id()}' with UUID '{$this->uuid()}' when this entity already exists with UUID '{$original->uuid()}'");
            }
        }
        if (!$this->isSyncing()) {
            // Ensure the correct dependencies are present. If the configuration is
            // being written during a configuration synchronization then there is no
            // need to recalculate the dependencies.
            $this->calculateDependencies();
            // If the data is trusted we need to ensure that the dependencies are
            // sorted as per their schema. If the save is not trusted then the
            // configuration will be sorted by StorableConfigBase.
            if ($this->trustedData) {
                $mapping = [
                    'config' => 0,
                    'content' => 1,
                    'module' => 2,
                    'theme' => 3,
                    'enforced' => 4,
                ];
                $dependency_sort = function ($dependencies) use ($mapping) {
                    // Only sort the keys that exist.
                    $mapping_to_replace = array_intersect_key($mapping, $dependencies);
                    return array_replace($mapping_to_replace, $dependencies);
                };
                $this->dependencies = $dependency_sort($this->dependencies);
                if (isset($this->dependencies['enforced'])) {
                    $this->dependencies['enforced'] = $dependency_sort($this->dependencies['enforced']);
                }
            }
        }
    }
    
    /**
     * {@inheritdoc}
     */
    public function __sleep() {
        $keys_to_unset = [];
        if ($this instanceof EntityWithPluginCollectionInterface) {
            // Get the plugin collections first, so that the properties are
            // initialized in $vars and can be found later.
            $plugin_collections = $this->getPluginCollections();
            $vars = get_object_vars($this);
            foreach ($plugin_collections as $plugin_config_key => $plugin_collection) {
                // Save any changes to the plugin configuration to the entity.
                $this->set($plugin_config_key, $plugin_collection->getConfiguration());
                // If the plugin collections are stored as properties on the entity,
                // mark them to be unset.
                $keys_to_unset += array_filter($vars, function ($value) use ($plugin_collection) {
                    return $plugin_collection === $value;
                });
            }
        }
        $vars = parent::__sleep();
        if (!empty($keys_to_unset)) {
            $vars = array_diff($vars, array_keys($keys_to_unset));
        }
        return $vars;
    }
    
    /**
     * {@inheritdoc}
     */
    public function calculateDependencies() {
        // All dependencies should be recalculated on every save apart from enforced
        // dependencies. This ensures stale dependencies are never saved.
        $this->dependencies = array_intersect_key($this->dependencies ?? [], [
            'enforced' => '',
        ]);
        if ($this instanceof EntityWithPluginCollectionInterface) {
            // Configuration entities need to depend on the providers of any plugins
            // that they store the configuration for.
            foreach ($this->getPluginCollections() as $plugin_collection) {
                foreach ($plugin_collection as $instance) {
                    $this->calculatePluginDependencies($instance);
                }
            }
        }
        if ($this instanceof ThirdPartySettingsInterface) {
            // Configuration entities need to depend on the providers of any third
            // parties that they store the configuration for.
            foreach ($this->getThirdPartyProviders() as $provider) {
                $this->addDependency('module', $provider);
            }
        }
        return $this;
    }
    
    /**
     * {@inheritdoc}
     */
    public function toUrl($rel = NULL, array $options = []) {
        // Unless language was already provided, avoid setting an explicit language.
        $options += [
            'language' => NULL,
        ];
        return parent::toUrl($rel, $options);
    }
    
    /**
     * {@inheritdoc}
     */
    public function getCacheTagsToInvalidate() {
        // Use cache tags that match the underlying config object's name.
        // @see \Drupal\Core\Config\ConfigBase::getCacheTags()
        return [
            'config:' . $this->getConfigDependencyName(),
        ];
    }
    
    /**
     * Overrides \Drupal\Core\Entity\DependencyTrait:addDependency().
     *
     * Note that this function should only be called from implementations of
     * \Drupal\Core\Config\Entity\ConfigEntityInterface::calculateDependencies(),
     * as dependencies are recalculated during every entity save.
     *
     * @see \Drupal\Core\Config\Entity\ConfigEntityDependency::hasDependency()
     */
    protected function addDependency($type, $name) {
        // A config entity is always dependent on its provider. There is no need to
        // explicitly declare the dependency. An explicit dependency on Core, which
        // provides some plugins, is also not needed.
        if ($type == 'module' && ($name == $this->getEntityType()
            ->getProvider() || $name == 'core')) {
            return $this;
        }
        return $this->addDependencyTrait($type, $name);
    }
    
    /**
     * {@inheritdoc}
     */
    public function getDependencies() {
        $dependencies = $this->dependencies;
        if (isset($dependencies['enforced'])) {
            // Merge the enforced dependencies into the list of dependencies.
            $enforced_dependencies = $dependencies['enforced'];
            unset($dependencies['enforced']);
            $dependencies = NestedArray::mergeDeep($dependencies, $enforced_dependencies);
        }
        return $dependencies;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getConfigDependencyName() {
        return $this->getEntityType()
            ->getConfigPrefix() . '.' . $this->id();
    }
    
    /**
     * {@inheritdoc}
     */
    public function getConfigTarget() {
        // For configuration entities, use the config ID for the config target
        // identifier. This ensures that default configuration (which does not yet
        // have UUIDs) can be provided and installed with references to the target,
        // and also makes config dependencies more readable.
        return $this->id();
    }
    
    /**
     * {@inheritdoc}
     */
    public function onDependencyRemoval(array $dependencies) {
        $changed = FALSE;
        if (!empty($this->third_party_settings)) {
            $old_count = count($this->third_party_settings);
            $this->third_party_settings = array_diff_key($this->third_party_settings, array_flip($dependencies['module']));
            $changed = $old_count != count($this->third_party_settings);
        }
        return $changed;
    }
    
    /**
     * {@inheritdoc}
     *
     * Override to never invalidate the entity's cache tag; the config system
     * already invalidates it.
     */
    protected function invalidateTagsOnSave($update) {
        Cache::invalidateTags($this->getListCacheTagsToInvalidate());
    }
    
    /**
     * {@inheritdoc}
     *
     * Override to never invalidate the individual entities' cache tags; the
     * config system already invalidates them.
     */
    protected static function invalidateTagsOnDelete(EntityTypeInterface $entity_type, array $entities) {
        $tags = $entity_type->getListCacheTags();
        foreach ($entities as $entity) {
            $tags = Cache::mergeTags($tags, $entity->getListCacheTagsToInvalidate());
        }
        Cache::invalidateTags($tags);
    }
    
    /**
     * {@inheritdoc}
     */
    public function setThirdPartySetting($module, $key, $value) {
        $this->third_party_settings[$module][$key] = $value;
        return $this;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getThirdPartySetting($module, $key, $default = NULL) {
        if (isset($this->third_party_settings[$module][$key])) {
            return $this->third_party_settings[$module][$key];
        }
        else {
            return $default;
        }
    }
    
    /**
     * {@inheritdoc}
     */
    public function getThirdPartySettings($module) {
        return $this->third_party_settings[$module] ?? [];
    }
    
    /**
     * {@inheritdoc}
     */
    public function unsetThirdPartySetting($module, $key) {
        unset($this->third_party_settings[$module][$key]);
        // If the third party is no longer storing any information, completely
        // remove the array holding the settings for this module.
        if (empty($this->third_party_settings[$module])) {
            unset($this->third_party_settings[$module]);
        }
        return $this;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getThirdPartyProviders() {
        return array_keys($this->third_party_settings);
    }
    
    /**
     * {@inheritdoc}
     */
    public static function preDelete(EntityStorageInterface $storage, array $entities) {
        parent::preDelete($storage, $entities);
        foreach ($entities as $entity) {
            if ($entity->isUninstalling() || $entity->isSyncing()) {
                // During extension uninstall and configuration synchronization
                // deletions are already managed.
                break;
            }
            // Fix or remove any dependencies.
            $config_entities = static::getConfigManager()->getConfigEntitiesToChangeOnDependencyRemoval('config', [
                $entity->getConfigDependencyName(),
            ], FALSE);
            
            /** @var \Drupal\Core\Config\Entity\ConfigEntityInterface $dependent_entity */
            foreach ($config_entities['update'] as $dependent_entity) {
                $dependent_entity->save();
            }
            foreach ($config_entities['delete'] as $dependent_entity) {
                $dependent_entity->delete();
            }
        }
    }
    
    /**
     * Gets the configuration manager.
     *
     * @return \Drupal\Core\Config\ConfigManager
     *   The configuration manager.
     */
    protected static function getConfigManager() {
        return \Drupal::service('config.manager');
    }
    
    /**
     * {@inheritdoc}
     */
    public function isInstallable() {
        return TRUE;
    }
    
    /**
     * {@inheritdoc}
     */
    public function trustData() {
        $this->trustedData = TRUE;
        return $this;
    }
    
    /**
     * {@inheritdoc}
     */
    public function hasTrustedData() {
        return $this->trustedData;
    }
    
    /**
     * {@inheritdoc}
     */
    public function save() {
        $return = parent::save();
        $this->trustedData = FALSE;
        return $return;
    }

}

Members

Title Sort descending Modifiers Object type Summary Member alias Overriden Title Overrides
CacheableDependencyTrait::$cacheContexts protected property Cache contexts.
CacheableDependencyTrait::$cacheMaxAge protected property Cache max-age.
CacheableDependencyTrait::$cacheTags protected property Cache tags.
CacheableDependencyTrait::setCacheability protected function Sets cacheability; useful for value object constructors.
ConfigEntityBase::$isUninstalling private property Whether the config is being deleted by the uninstall process.
ConfigEntityBase::$langcode protected property The language code of the entity&#039;s default language.
ConfigEntityBase::$originalId protected property The original ID of the configuration entity.
ConfigEntityBase::$status protected property The enabled/disabled status of the configuration entity. 4
ConfigEntityBase::$third_party_settings protected property
ConfigEntityBase::$trustedData protected property Trust supplied data and not use configuration schema on save.
ConfigEntityBase::$uuid protected property The UUID for this entity.
ConfigEntityBase::$_core protected property
ConfigEntityBase::addDependency protected function Overrides \Drupal\Core\Entity\DependencyTrait:addDependency().
ConfigEntityBase::calculateDependencies public function Calculates dependencies and stores them in the dependency property. Overrides ConfigEntityInterface::calculateDependencies 13
ConfigEntityBase::createDuplicate public function Creates a duplicate of the entity. Overrides EntityBase::createDuplicate 1
ConfigEntityBase::disable public function Disables the configuration entity. Overrides ConfigEntityInterface::disable 1
ConfigEntityBase::enable public function Enables the configuration entity. Overrides ConfigEntityInterface::enable
ConfigEntityBase::get public function Returns the value of a property. Overrides ConfigEntityInterface::get
ConfigEntityBase::getCacheTagsToInvalidate public function Returns the cache tags that should be used to invalidate caches. Overrides EntityBase::getCacheTagsToInvalidate 1
ConfigEntityBase::getConfigDependencyName public function Gets the configuration dependency name. Overrides EntityBase::getConfigDependencyName
ConfigEntityBase::getConfigManager protected static function Gets the configuration manager.
ConfigEntityBase::getConfigTarget public function Gets the configuration target identifier for the entity. Overrides EntityBase::getConfigTarget
ConfigEntityBase::getDependencies public function Gets the configuration dependencies. Overrides ConfigEntityInterface::getDependencies
ConfigEntityBase::getOriginalId public function Gets the original ID. Overrides EntityBase::getOriginalId
ConfigEntityBase::getThirdPartyProviders public function Gets the list of third parties that store information. Overrides ThirdPartySettingsInterface::getThirdPartyProviders
ConfigEntityBase::getThirdPartySetting public function Gets the value of a third-party setting. Overrides ThirdPartySettingsInterface::getThirdPartySetting
ConfigEntityBase::getThirdPartySettings public function Gets all third-party settings of a given module. Overrides ThirdPartySettingsInterface::getThirdPartySettings
ConfigEntityBase::getTypedConfig protected function Gets the typed config manager.
ConfigEntityBase::hasTrustedData public function Gets whether on not the data is trusted. Overrides ConfigEntityInterface::hasTrustedData
ConfigEntityBase::invalidateTagsOnDelete protected static function Override to never invalidate the individual entities&#039; cache tags; the
config system already invalidates them.
Overrides EntityBase::invalidateTagsOnDelete
ConfigEntityBase::invalidateTagsOnSave protected function Override to never invalidate the entity&#039;s cache tag; the config system
already invalidates it.
Overrides EntityBase::invalidateTagsOnSave
ConfigEntityBase::isInstallable public function Checks whether this entity is installable. Overrides ConfigEntityInterface::isInstallable 2
ConfigEntityBase::isNew public function Overrides Entity::isNew(). Overrides EntityBase::isNew
ConfigEntityBase::isUninstalling public function Returns whether this entity is being changed during the uninstall process. Overrides ConfigEntityInterface::isUninstalling
ConfigEntityBase::onDependencyRemoval public function Informs the entity that entities it depends on will be deleted. Overrides ConfigEntityInterface::onDependencyRemoval 8
ConfigEntityBase::preDelete public static function Acts on entities before they are deleted and before hooks are invoked. Overrides EntityBase::preDelete 8
ConfigEntityBase::preSave public function Acts on an entity before the presave hook is invoked. Overrides EntityBase::preSave 14
ConfigEntityBase::save public function Saves an entity permanently. Overrides EntityBase::save 2
ConfigEntityBase::set public function Sets the value of a property. Overrides ConfigEntityInterface::set
ConfigEntityBase::setOriginalId public function Sets the original ID. Overrides EntityBase::setOriginalId
ConfigEntityBase::setStatus public function Sets the status of the configuration entity. Overrides ConfigEntityInterface::setStatus
ConfigEntityBase::setThirdPartySetting public function Sets the value of a third-party setting. Overrides ThirdPartySettingsInterface::setThirdPartySetting
ConfigEntityBase::setUninstalling public function
ConfigEntityBase::sort public static function Helper callback for uasort() to sort configuration entities by weight and label. 6
ConfigEntityBase::status public function Returns whether the configuration entity is enabled. Overrides ConfigEntityInterface::status 4
ConfigEntityBase::toArray public function Gets an array of all property values. Overrides EntityBase::toArray 3
ConfigEntityBase::toUrl public function Gets the URL object for the entity. Overrides EntityBase::toUrl
ConfigEntityBase::trustData public function Sets that the data should be trusted. Overrides ConfigEntityInterface::trustData
ConfigEntityBase::unsetThirdPartySetting public function Unsets a third-party setting. Overrides ThirdPartySettingsInterface::unsetThirdPartySetting
ConfigEntityBase::__construct public function Constructs an Entity object. Overrides EntityBase::__construct 10
ConfigEntityBase::__sleep public function Overrides EntityBase::__sleep 4
DependencySerializationTrait::$_entityStorages protected property
DependencySerializationTrait::$_serviceIds protected property
DependencySerializationTrait::__sleep public function Aliased as: traitSleep 1
DependencySerializationTrait::__wakeup public function 2
DependencyTrait::$dependencies protected property The object&#039;s dependencies.
DependencyTrait::addDependencies protected function Adds multiple dependencies.
DependencyTrait::addDependency protected function Adds a dependency. Aliased as: addDependencyTrait
EntityBase::$enforceIsNew protected property Boolean indicating whether the entity should be forced to be new.
EntityBase::$entityTypeId protected property The entity type.
EntityBase::$typedData protected property A typed data object wrapping this entity.
EntityBase::access public function Checks data value access. Overrides AccessibleInterface::access 1
EntityBase::bundle public function Gets the bundle of the entity. Overrides EntityInterface::bundle 1
EntityBase::create public static function Constructs a new entity object, without permanently saving it. Overrides EntityInterface::create 2
EntityBase::delete public function Deletes an entity permanently. Overrides EntityInterface::delete 1
EntityBase::enforceIsNew public function Enforces an entity to be new. Overrides EntityInterface::enforceIsNew
EntityBase::entityTypeBundleInfo protected function Gets the entity type bundle info service.
EntityBase::entityTypeManager protected function Gets the entity type manager.
EntityBase::getCacheContexts public function The cache contexts associated with this object. Overrides CacheableDependencyTrait::getCacheContexts
EntityBase::getCacheMaxAge public function The maximum age for which this object may be cached. Overrides CacheableDependencyTrait::getCacheMaxAge
EntityBase::getCacheTags public function The cache tags associated with this object. Overrides CacheableDependencyTrait::getCacheTags
EntityBase::getConfigDependencyKey public function Gets the key that is used to store configuration dependencies. Overrides EntityInterface::getConfigDependencyKey
EntityBase::getEntityType public function Gets the entity type definition. Overrides EntityInterface::getEntityType
EntityBase::getEntityTypeId public function Gets the ID of the type of the entity. Overrides EntityInterface::getEntityTypeId
EntityBase::getListCacheTagsToInvalidate protected function The list cache tags to invalidate for this entity.
EntityBase::getTypedData public function Gets a typed data object for this entity object. Overrides EntityInterface::getTypedData
EntityBase::getTypedDataClass private function Returns the typed data class name for this entity.
EntityBase::hasLinkTemplate public function Indicates if a link template exists for a given key. Overrides EntityInterface::hasLinkTemplate
EntityBase::id public function Gets the identifier. Overrides EntityInterface::id 10
EntityBase::label public function Gets the label of the entity. Overrides EntityInterface::label 6
EntityBase::language public function Gets the language of the entity. Overrides EntityInterface::language 1
EntityBase::languageManager protected function Gets the language manager.
EntityBase::linkTemplates protected function Gets an array link templates. 1
EntityBase::load public static function Loads an entity. Overrides EntityInterface::load
EntityBase::loadMultiple public static function Loads one or more entities. Overrides EntityInterface::loadMultiple
EntityBase::postCreate public function Acts on a created entity before hooks are invoked. Overrides EntityInterface::postCreate 5
EntityBase::postDelete public static function Acts on deleted entities before the delete hook is invoked. Overrides EntityInterface::postDelete 17
EntityBase::postLoad public static function Acts on loaded entities. Overrides EntityInterface::postLoad 3
EntityBase::postSave public function Acts on a saved entity before the insert or update hook is invoked. Overrides EntityInterface::postSave 13
EntityBase::preCreate public static function Changes the values of an entity before it is created. Overrides EntityInterface::preCreate 6
EntityBase::referencedEntities public function Gets a list of entities referenced by this entity. Overrides EntityInterface::referencedEntities 1
EntityBase::toLink public function Generates the HTML for a link to this entity. Overrides EntityInterface::toLink
EntityBase::uriRelationships public function Gets a list of URI relationships supported by this entity. Overrides EntityInterface::uriRelationships
EntityBase::urlRouteParameters protected function Gets an array of placeholders for this entity. 2
EntityBase::uuid public function Gets the entity UUID (Universally Unique Identifier). Overrides EntityInterface::uuid 1
EntityBase::uuidGenerator protected function Gets the UUID generator.
PluginDependencyTrait::calculatePluginDependencies protected function Calculates and adds dependencies of a specific plugin instance. 1
PluginDependencyTrait::getPluginDependencies protected function Calculates and returns dependencies of a specific plugin instance.
PluginDependencyTrait::moduleHandler protected function Wraps the module handler. 1
PluginDependencyTrait::themeHandler protected function Wraps the theme handler. 1
RefinableCacheableDependencyTrait::addCacheableDependency public function 1
RefinableCacheableDependencyTrait::addCacheContexts public function
RefinableCacheableDependencyTrait::addCacheTags public function
RefinableCacheableDependencyTrait::mergeCacheMaxAge public function
SynchronizableEntityTrait::$isSyncing protected property Is entity being created updated or deleted through synchronization process.
SynchronizableEntityTrait::isSyncing public function
SynchronizableEntityTrait::setSyncing public function

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