class ContentEntityStorageBase
Same name in other branches
- 9 core/lib/Drupal/Core/Entity/ContentEntityStorageBase.php \Drupal\Core\Entity\ContentEntityStorageBase
- 8.9.x core/lib/Drupal/Core/Entity/ContentEntityStorageBase.php \Drupal\Core\Entity\ContentEntityStorageBase
- 10 core/lib/Drupal/Core/Entity/ContentEntityStorageBase.php \Drupal\Core\Entity\ContentEntityStorageBase
Base class for content entity storage handlers.
Hierarchy
- class \Drupal\Core\Entity\EntityHandlerBase uses \Drupal\Core\StringTranslation\StringTranslationTrait, \Drupal\Core\DependencyInjection\DependencySerializationTrait
- class \Drupal\Core\Entity\EntityStorageBase extends \Drupal\Core\Entity\EntityHandlerBase implements \Drupal\Core\Entity\EntityStorageInterface, \Drupal\Core\Entity\EntityHandlerInterface
- class \Drupal\Core\Entity\ContentEntityStorageBase extends \Drupal\Core\Entity\EntityStorageBase implements \Drupal\Core\Entity\ContentEntityStorageInterface, \Drupal\Core\Entity\DynamicallyFieldableEntityStorageInterface, \Drupal\Core\Entity\BundleEntityStorageInterface
- class \Drupal\Core\Entity\EntityStorageBase extends \Drupal\Core\Entity\EntityHandlerBase implements \Drupal\Core\Entity\EntityStorageInterface, \Drupal\Core\Entity\EntityHandlerInterface
Expanded class hierarchy of ContentEntityStorageBase
1 file declares its use of ContentEntityStorageBase
- SqlContentEntityStorage.php in core/
lib/ Drupal/ Core/ Entity/ Sql/ SqlContentEntityStorage.php
File
-
core/
lib/ Drupal/ Core/ Entity/ ContentEntityStorageBase.php, line 20
Namespace
Drupal\Core\EntityView source
abstract class ContentEntityStorageBase extends EntityStorageBase implements ContentEntityStorageInterface, DynamicallyFieldableEntityStorageInterface, BundleEntityStorageInterface {
/**
* The entity bundle key.
*
* @var string|bool
*/
protected $bundleKey = FALSE;
/**
* The entity field manager service.
*
* @var \Drupal\Core\Entity\EntityFieldManagerInterface
*/
protected $entityFieldManager;
/**
* The entity bundle info.
*
* @var \Drupal\Core\Entity\EntityTypeBundleInfoInterface
*/
protected $entityTypeBundleInfo;
/**
* Cache backend.
*
* @var \Drupal\Core\Cache\CacheBackendInterface
*/
protected $cacheBackend;
/**
* Stores the latest revision IDs for entities.
*
* @var array
*/
protected $latestRevisionIds = [];
/**
* Constructs a ContentEntityStorageBase object.
*
* @param \Drupal\Core\Entity\EntityTypeInterface $entity_type
* The entity type definition.
* @param \Drupal\Core\Entity\EntityFieldManagerInterface $entity_field_manager
* The entity field manager.
* @param \Drupal\Core\Cache\CacheBackendInterface $cache
* The cache backend to be used.
* @param \Drupal\Core\Cache\MemoryCache\MemoryCacheInterface $memory_cache
* The memory cache backend.
* @param \Drupal\Core\Entity\EntityTypeBundleInfoInterface $entity_type_bundle_info
* The entity type bundle info.
*/
public function __construct(EntityTypeInterface $entity_type, EntityFieldManagerInterface $entity_field_manager, CacheBackendInterface $cache, MemoryCacheInterface $memory_cache, EntityTypeBundleInfoInterface $entity_type_bundle_info) {
parent::__construct($entity_type, $memory_cache);
$this->bundleKey = $this->entityType
->getKey('bundle');
$this->entityFieldManager = $entity_field_manager;
$this->cacheBackend = $cache;
$this->entityTypeBundleInfo = $entity_type_bundle_info;
}
/**
* {@inheritdoc}
*/
public function create(array $values = []) {
$bundle = $this->getBundleFromValues($values);
$entity_class = $this->getEntityClass($bundle);
// @todo Decide what to do if preCreate() tries to change the bundle.
// @see https://www.drupal.org/project/drupal/issues/3230792
$entity_class::preCreate($this, $values);
// Assign a new UUID if there is none yet.
if ($this->uuidKey && $this->uuidService && !isset($values[$this->uuidKey])) {
$values[$this->uuidKey] = $this->uuidService
->generate();
}
$entity = $this->doCreate($values);
$entity->enforceIsNew();
$entity->postCreate($this);
// Modules might need to add or change the data initially held by the new
// entity object, for instance to fill-in default values.
$this->invokeHook('create', $entity);
return $entity;
}
/**
* {@inheritdoc}
*/
public static function createInstance(ContainerInterface $container, EntityTypeInterface $entity_type) {
return new static($entity_type, $container->get('entity_field.manager'), $container->get('cache.entity'), $container->get('entity.memory_cache'), $container->get('entity_type.bundle.info'));
}
/**
* {@inheritdoc}
*/
protected function doCreate(array $values) {
$bundle = $this->getBundleFromValues($values);
if ($this->bundleKey && !$bundle) {
throw new EntityStorageException('Missing bundle for entity type ' . $this->entityTypeId);
}
$entity_class = $this->getEntityClass($bundle);
$entity = new $entity_class([], $this->entityTypeId, $bundle);
$this->initFieldValues($entity, $values);
return $entity;
}
/**
* {@inheritdoc}
*/
public function getBundleFromClass(string $class_name) : ?string {
$bundle_for_class = NULL;
foreach ($this->entityTypeBundleInfo
->getBundleInfo($this->entityTypeId) as $bundle => $bundle_info) {
if (!empty($bundle_info['class']) && $bundle_info['class'] === $class_name) {
if ($bundle_for_class) {
throw new AmbiguousBundleClassException($class_name);
}
else {
$bundle_for_class = $bundle;
}
}
}
return $bundle_for_class;
}
/**
* Retrieves the bundle from an array of values.
*
* @param array $values
* An array of values to set, keyed by field name.
*
* @return string|null
* The bundle or NULL if not set.
*/
protected function getBundleFromValues(array $values) : ?string {
$bundle = NULL;
// Make sure we have a reasonable bundle key. If not, bail early.
if (!$this->bundleKey || !isset($values[$this->bundleKey])) {
return NULL;
}
// Normalize the bundle value. This is an optimized version of
// \Drupal\Core\Field\FieldInputValueNormalizerTrait::normalizeValue()
// because we just need the scalar value.
$bundle_value = $values[$this->bundleKey];
if (!is_array($bundle_value)) {
// The bundle value is a scalar, use it as-is.
$bundle = $bundle_value;
}
elseif (is_numeric(array_keys($bundle_value)[0])) {
// The bundle value is a field item list array, keyed by delta.
$bundle = reset($bundle_value[0]);
}
else {
// The bundle value is a field item array, keyed by the field's main
// property name.
$bundle = reset($bundle_value);
}
return $bundle;
}
/**
* {@inheritdoc}
*/
public function getEntityClass(?string $bundle = NULL) : string {
$entity_class = parent::getEntityClass();
// If no bundle is set, use the entity type ID as the bundle ID.
$bundle = $bundle ?? $this->getEntityTypeId();
// Return the bundle class if it has been defined for this bundle.
$bundle_info = $this->entityTypeBundleInfo
->getBundleInfo($this->entityTypeId);
$bundle_class = $bundle_info[$bundle]['class'] ?? NULL;
// Bundle classes should exist and extend the main entity class.
if ($bundle_class) {
if (!class_exists($bundle_class)) {
throw new MissingBundleClassException($bundle_class);
}
elseif (!is_subclass_of($bundle_class, $entity_class)) {
throw new BundleClassInheritanceException($bundle_class, $entity_class);
}
return $bundle_class;
}
return $entity_class;
}
/**
* {@inheritdoc}
*/
public function createWithSampleValues($bundle = FALSE, array $values = []) {
// ID and revision should never have sample values generated for them.
$forbidden_keys = [
$this->entityType
->getKey('id'),
];
if ($revision_key = $this->entityType
->getKey('revision')) {
$forbidden_keys[] = $revision_key;
}
if ($bundle_key = $this->entityType
->getKey('bundle')) {
if (!$bundle) {
throw new EntityStorageException("No entity bundle was specified");
}
if (!array_key_exists($bundle, $this->entityTypeBundleInfo
->getBundleInfo($this->entityTypeId))) {
throw new EntityStorageException(sprintf("Missing entity bundle. The \"%s\" bundle does not exist", $bundle));
}
$values[$bundle_key] = $bundle;
// Bundle is already set
$forbidden_keys[] = $bundle_key;
}
// Forbid sample generation on any keys whose values were submitted.
$forbidden_keys = array_merge($forbidden_keys, array_keys($values));
/** @var \Drupal\Core\Entity\FieldableEntityInterface $entity */
$entity = $this->create($values);
foreach ($entity as $field_name => $value) {
if (!in_array($field_name, $forbidden_keys, TRUE)) {
$entity->get($field_name)
->generateSampleItems();
}
}
return $entity;
}
/**
* Initializes field values.
*
* @param \Drupal\Core\Entity\ContentEntityInterface $entity
* An entity object.
* @param array $values
* (optional) An associative array of initial field values keyed by field
* name. If none is provided default values will be applied.
* @param array $field_names
* (optional) An associative array of field names to be initialized. If none
* is provided all fields will be initialized.
*/
protected function initFieldValues(ContentEntityInterface $entity, array $values = [], array $field_names = []) {
// Populate field values.
foreach ($entity as $name => $field) {
if (!$field_names || isset($field_names[$name])) {
if (isset($values[$name])) {
$entity->{$name} = $values[$name];
}
elseif (!array_key_exists($name, $values)) {
$entity->get($name)
->applyDefaultValue();
}
}
unset($values[$name]);
}
// Set any passed values for non-defined fields also.
foreach ($values as $name => $value) {
$entity->{$name} = $value;
}
// Make sure modules can alter field initial values.
$this->invokeHook('field_values_init', $entity);
}
/**
* Checks whether any entity revision is translated.
*
* @param \Drupal\Core\Entity\TranslatableInterface $entity
* The entity object to be checked.
*
* @return bool
* TRUE if the entity has at least one translation in any revision, FALSE
* otherwise.
*
* @see \Drupal\Core\TypedData\TranslatableInterface::getTranslationLanguages()
* @see \Drupal\Core\Entity\ContentEntityStorageBase::isAnyStoredRevisionTranslated()
*/
protected function isAnyRevisionTranslated(TranslatableInterface $entity) {
return $entity->getTranslationLanguages(FALSE) || $this->isAnyStoredRevisionTranslated($entity);
}
/**
* Checks whether any stored entity revision is translated.
*
* A revisionable entity can have translations in a pending revision, hence
* the default revision may appear as not translated. This determines whether
* the entity has any translation in the storage and thus should be considered
* as multilingual.
*
* @param \Drupal\Core\Entity\TranslatableInterface $entity
* The entity object to be checked.
*
* @return bool
* TRUE if the entity has at least one translation in any revision, FALSE
* otherwise.
*
* @see \Drupal\Core\TypedData\TranslatableInterface::getTranslationLanguages()
* @see \Drupal\Core\Entity\ContentEntityStorageBase::isAnyRevisionTranslated()
*/
protected function isAnyStoredRevisionTranslated(TranslatableInterface $entity) {
/** @var \Drupal\Core\Entity\ContentEntityInterface $entity */
if ($entity->isNew()) {
return FALSE;
}
if ($entity instanceof TranslationStatusInterface) {
foreach ($entity->getTranslationLanguages(FALSE) as $langcode => $language) {
if ($entity->getTranslationStatus($langcode) === TranslationStatusInterface::TRANSLATION_EXISTING) {
return TRUE;
}
}
}
$query = $this->getQuery()
->condition($this->entityType
->getKey('id'), $entity->id())
->condition($this->entityType
->getKey('default_langcode'), 0)
->accessCheck(FALSE)
->range(0, 1);
if ($entity->getEntityType()
->isRevisionable()) {
$query->allRevisions();
}
$result = $query->execute();
return !empty($result);
}
/**
* {@inheritdoc}
*/
public function createTranslation(ContentEntityInterface $entity, $langcode, array $values = []) {
$translation = $entity->getTranslation($langcode);
$definitions = array_filter($translation->getFieldDefinitions(), function (FieldDefinitionInterface $definition) {
return $definition->isTranslatable();
});
$field_names = array_map(function (FieldDefinitionInterface $definition) {
return $definition->getName();
}, $definitions);
$values[$this->langcodeKey] = $langcode;
$values[$this->getEntityType()
->getKey('default_langcode')] = FALSE;
$this->initFieldValues($translation, $values, $field_names);
$this->invokeHook('translation_create', $translation);
return $translation;
}
/**
* {@inheritdoc}
*/
public function createRevision(RevisionableInterface $entity, $default = TRUE, $keep_untranslatable_fields = NULL) {
/** @var \Drupal\Core\Entity\ContentEntityInterface $entity */
$new_revision = clone $entity;
$original_keep_untranslatable_fields = $keep_untranslatable_fields;
// For translatable entities, create a merged revision of the active
// translation and the other translations in the default revision. This
// permits the creation of pending revisions that can always be saved as the
// new default revision without reverting changes in other languages.
if (!$entity->isNew() && !$entity->isDefaultRevision() && $entity->isTranslatable() && $this->isAnyRevisionTranslated($entity)) {
$active_langcode = $entity->language()
->getId();
$skipped_field_names = array_flip($this->getRevisionTranslationMergeSkippedFieldNames());
// By default we copy untranslatable field values from the default
// revision, unless they are configured to affect only the default
// translation. This way we can ensure we always have only one affected
// translation in pending revisions. This constraint is enforced by
// EntityUntranslatableFieldsConstraintValidator.
if (!isset($keep_untranslatable_fields)) {
$keep_untranslatable_fields = $entity->isDefaultTranslation() && $entity->isDefaultTranslationAffectedOnly();
}
/** @var \Drupal\Core\Entity\ContentEntityInterface $default_revision */
$default_revision = $this->load($entity->id());
$translation_languages = $default_revision->getTranslationLanguages();
foreach ($translation_languages as $langcode => $language) {
if ($langcode == $active_langcode) {
continue;
}
$default_revision_translation = $default_revision->getTranslation($langcode);
$new_revision_translation = $new_revision->hasTranslation($langcode) ? $new_revision->getTranslation($langcode) : $new_revision->addTranslation($langcode);
/** @var \Drupal\Core\Field\FieldItemListInterface[] $sync_items */
$sync_items = array_diff_key($keep_untranslatable_fields ? $default_revision_translation->getTranslatableFields() : $default_revision_translation->getFields(), $skipped_field_names);
foreach ($sync_items as $field_name => $items) {
$new_revision_translation->set($field_name, $items->getValue());
}
// Make sure the "revision_translation_affected" flag is recalculated.
$new_revision_translation->setRevisionTranslationAffected(NULL);
// No need to copy untranslatable field values more than once.
$keep_untranslatable_fields = TRUE;
}
// Make sure we do not inadvertently recreate removed translations.
foreach (array_diff_key($new_revision->getTranslationLanguages(), $translation_languages) as $langcode => $language) {
// Allow a new revision to be created for the active language.
if ($langcode !== $active_langcode) {
$new_revision->removeTranslation($langcode);
}
}
// The "original" property is used in various places to detect changes in
// field values with respect to the stored ones. If the property is not
// defined, the stored version is loaded explicitly. Since the merged
// revision generated here is not stored anywhere, we need to populate the
// "original" property manually, so that changes can be properly detected.
$new_revision->original = clone $new_revision;
}
// Eventually mark the new revision as such.
$new_revision->setNewRevision();
$new_revision->isDefaultRevision($default);
// Actually make sure the current translation is marked as affected, even if
// there are no explicit changes, to be sure this revision can be related
// to the correct translation.
$new_revision->setRevisionTranslationAffected(TRUE);
// Notify modules about the new revision.
$arguments = [
$new_revision,
$entity,
$original_keep_untranslatable_fields,
];
$this->moduleHandler()
->invokeAll($this->entityTypeId . '_revision_create', $arguments);
$this->moduleHandler()
->invokeAll('entity_revision_create', $arguments);
return $new_revision;
}
/**
* Returns an array of field names to skip when merging revision translations.
*
* @return array
* An array of field names.
*/
protected function getRevisionTranslationMergeSkippedFieldNames() {
/** @var \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type */
$entity_type = $this->getEntityType();
// A list of known revision metadata fields which should be skipped from
// the comparison.
$field_names = [
$entity_type->getKey('revision'),
$entity_type->getKey('revision_translation_affected'),
];
$field_names = array_merge($field_names, array_values($entity_type->getRevisionMetadataKeys()));
return $field_names;
}
/**
* {@inheritdoc}
*/
public function getLatestRevisionId($entity_id) {
if (!$this->entityType
->isRevisionable()) {
return NULL;
}
if (!isset($this->latestRevisionIds[$entity_id][LanguageInterface::LANGCODE_DEFAULT])) {
$result = $this->getQuery()
->latestRevision()
->condition($this->entityType
->getKey('id'), $entity_id)
->accessCheck(FALSE)
->execute();
$this->latestRevisionIds[$entity_id][LanguageInterface::LANGCODE_DEFAULT] = key($result);
}
return $this->latestRevisionIds[$entity_id][LanguageInterface::LANGCODE_DEFAULT];
}
/**
* {@inheritdoc}
*/
public function getLatestTranslationAffectedRevisionId($entity_id, $langcode) {
if (!$this->entityType
->isRevisionable()) {
return NULL;
}
if (!$this->entityType
->isTranslatable()) {
return $this->getLatestRevisionId($entity_id);
}
if (!isset($this->latestRevisionIds[$entity_id][$langcode])) {
$result = $this->getQuery()
->allRevisions()
->condition($this->entityType
->getKey('id'), $entity_id)
->condition($this->entityType
->getKey('revision_translation_affected'), 1, '=', $langcode)
->range(0, 1)
->sort($this->entityType
->getKey('revision'), 'DESC')
->accessCheck(FALSE)
->execute();
$this->latestRevisionIds[$entity_id][$langcode] = key($result);
}
return $this->latestRevisionIds[$entity_id][$langcode];
}
/**
* {@inheritdoc}
*/
public function onFieldStorageDefinitionCreate(FieldStorageDefinitionInterface $storage_definition) {
}
/**
* {@inheritdoc}
*/
public function onFieldStorageDefinitionUpdate(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original) {
}
/**
* {@inheritdoc}
*/
public function onFieldStorageDefinitionDelete(FieldStorageDefinitionInterface $storage_definition) {
}
/**
* {@inheritdoc}
*/
public function onFieldDefinitionCreate(FieldDefinitionInterface $field_definition) {
}
/**
* {@inheritdoc}
*/
public function onFieldDefinitionUpdate(FieldDefinitionInterface $field_definition, FieldDefinitionInterface $original) {
}
/**
* {@inheritdoc}
*/
public function onFieldDefinitionDelete(FieldDefinitionInterface $field_definition) {
}
/**
* {@inheritdoc}
*/
public function purgeFieldData(FieldDefinitionInterface $field_definition, $batch_size) {
$items_by_entity = $this->readFieldItemsToPurge($field_definition, $batch_size);
foreach ($items_by_entity as $items) {
$items->delete();
$this->purgeFieldItems($items->getEntity(), $field_definition);
}
return count($items_by_entity);
}
/**
* Reads values to be purged for a single field.
*
* This method is called during field data purge, on fields for which
* onFieldDefinitionDelete() has previously run.
*
* @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
* The field definition.
* @param $batch_size
* The maximum number of field data records to purge before returning.
*
* @return \Drupal\Core\Field\FieldItemListInterface[]
* An array of field item lists, keyed by entity revision id.
*/
protected abstract function readFieldItemsToPurge(FieldDefinitionInterface $field_definition, $batch_size);
/**
* Removes field items from storage per entity during purge.
*
* @param ContentEntityInterface $entity
* The entity revision, whose values are being purged.
* @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
* The field whose values are bing purged.
*/
protected abstract function purgeFieldItems(ContentEntityInterface $entity, FieldDefinitionInterface $field_definition);
/**
* {@inheritdoc}
*/
public function finalizePurge(FieldStorageDefinitionInterface $storage_definition) {
}
/**
* {@inheritdoc}
*/
protected function preLoad(?array &$ids = NULL) {
$entities = [];
// Call hook_entity_preload().
$preload_ids = $ids ?: [];
$preload_entities = $this->moduleHandler()
->invokeAll('entity_preload', [
$preload_ids,
$this->entityTypeId,
]);
foreach ((array) $preload_entities as $entity) {
$entities[$entity->id()] = $entity;
}
if ($entities) {
// If any entities were pre-loaded, remove them from the IDs still to
// load.
if ($ids !== NULL) {
$ids = array_keys(array_diff_key(array_flip($ids), $entities));
}
else {
$result = $this->getQuery()
->accessCheck(FALSE)
->condition($this->entityType
->getKey('id'), array_keys($entities), 'NOT IN')
->execute();
$ids = array_values($result);
}
}
return $entities;
}
/**
* {@inheritdoc}
*/
public function loadRevision($revision_id) {
$revisions = $this->loadMultipleRevisions([
$revision_id,
]);
return $revisions[$revision_id] ?? NULL;
}
/**
* {@inheritdoc}
*/
public function loadMultipleRevisions(array $revision_ids) {
$revisions = $this->doLoadMultipleRevisionsFieldItems($revision_ids);
// The hooks are executed with an array of entities keyed by the entity ID.
// As we could load multiple revisions for the same entity ID at once we
// have to build groups of entities where the same entity ID is present only
// once.
$entity_groups = [];
$entity_group_mapping = [];
foreach ($revisions as $revision) {
$entity_id = $revision->id();
$entity_group_key = isset($entity_group_mapping[$entity_id]) ? $entity_group_mapping[$entity_id] + 1 : 0;
$entity_group_mapping[$entity_id] = $entity_group_key;
$entity_groups[$entity_group_key][$entity_id] = $revision;
}
// Invoke the entity hooks for each group.
foreach ($entity_groups as $entities) {
$this->invokeStorageLoadHook($entities);
$this->postLoad($entities);
}
// Ensure that the returned array is ordered the same as the original
// $ids array if this was passed in and remove any invalid IDs.
if ($revision_ids) {
$flipped_ids = array_intersect_key(array_flip($revision_ids), $revisions);
$revisions = array_replace($flipped_ids, $revisions);
}
return $revisions;
}
/**
* Actually loads revision field item values from the storage.
*
* @param array $revision_ids
* An array of revision identifiers.
*
* @return \Drupal\Core\Entity\EntityInterface[]
* The specified entity revisions or an empty array if none are found.
*/
protected abstract function doLoadMultipleRevisionsFieldItems($revision_ids);
/**
* {@inheritdoc}
*/
protected function doSave($id, EntityInterface $entity) {
/** @var \Drupal\Core\Entity\ContentEntityInterface $entity */
if ($entity->isNew()) {
// Ensure the entity is still seen as new after assigning it an id, while
// storing its data.
$entity->enforceIsNew();
if ($this->entityType
->isRevisionable()) {
$entity->setNewRevision();
}
$return = SAVED_NEW;
}
else {
// @todo Consider returning a different value when saving a non-default
// entity revision. See https://www.drupal.org/node/2509360.
$return = $entity->isDefaultRevision() ? SAVED_UPDATED : FALSE;
}
$this->populateAffectedRevisionTranslations($entity);
// Populate the "revision_default" flag. Skip this when we are resaving
// the revision, and the flag is set to FALSE, since it is not possible to
// set a previously default revision to non-default. However, setting a
// previously non-default revision to default is allowed for advanced
// use-cases.
if ($this->entityType
->isRevisionable() && ($entity->isNewRevision() || $entity->isDefaultRevision())) {
$revision_default_key = $this->entityType
->getRevisionMetadataKey('revision_default');
$entity->set($revision_default_key, $entity->isDefaultRevision());
}
$this->doSaveFieldItems($entity);
return $return;
}
/**
* Writes entity field values to the storage.
*
* This method is responsible for allocating entity and revision identifiers
* and updating the entity object with their values.
*
* @param \Drupal\Core\Entity\ContentEntityInterface $entity
* The entity object.
* @param string[] $names
* (optional) The name of the fields to be written to the storage. If an
* empty value is passed all field values are saved.
*/
protected abstract function doSaveFieldItems(ContentEntityInterface $entity, array $names = []);
/**
* {@inheritdoc}
*/
protected function doPreSave(EntityInterface $entity) {
/** @var \Drupal\Core\Entity\ContentEntityBase $entity */
// Sync the changes made in the fields array to the internal values array.
$entity->updateOriginalValues();
if ($entity->getEntityType()
->isRevisionable() && !$entity->isNew() && empty($entity->getLoadedRevisionId())) {
// Update the loaded revision id for rare special cases when no loaded
// revision is given when updating an existing entity. This for example
// happens when calling save() in hook_entity_insert().
$entity->updateLoadedRevisionId();
}
$id = parent::doPreSave($entity);
if (!$entity->isNew()) {
// If the ID changed then original can't be loaded, throw an exception
// in that case.
if (empty($entity->original) || $entity->id() != $entity->original
->id()) {
throw new EntityStorageException("Update existing '{$this->entityTypeId}' entity while changing the ID is not supported.");
}
// Do not allow changing the revision ID when resaving the current
// revision.
if (!$entity->isNewRevision() && $entity->getRevisionId() != $entity->getLoadedRevisionId()) {
throw new EntityStorageException("Update existing '{$this->entityTypeId}' entity revision while changing the revision ID is not supported.");
}
}
return $id;
}
/**
* {@inheritdoc}
*/
protected function doPostSave(EntityInterface $entity, $update) {
/** @var \Drupal\Core\Entity\ContentEntityInterface $entity */
if ($update && $this->entityType
->isTranslatable()) {
$this->invokeTranslationHooks($entity);
}
parent::doPostSave($entity, $update);
// The revision is stored, it should no longer be marked as new now.
if ($this->entityType
->isRevisionable()) {
$entity->updateLoadedRevisionId();
$entity->setNewRevision(FALSE);
}
}
/**
* {@inheritdoc}
*/
protected function doDelete($entities) {
/** @var \Drupal\Core\Entity\ContentEntityInterface[] $entities */
foreach ($entities as $entity) {
$this->invokeFieldMethod('delete', $entity);
}
$this->doDeleteFieldItems($entities);
}
/**
* Deletes entity field values from the storage.
*
* @param \Drupal\Core\Entity\ContentEntityInterface[] $entities
* An array of entity objects to be deleted.
*/
protected abstract function doDeleteFieldItems($entities);
/**
* {@inheritdoc}
*/
public function deleteRevision($revision_id) {
/** @var \Drupal\Core\Entity\ContentEntityInterface $revision */
if ($revision = $this->loadRevision($revision_id)) {
// Prevent deletion if this is the default revision.
if ($revision->isDefaultRevision()) {
throw new EntityStorageException('Default revision can not be deleted');
}
$this->invokeFieldMethod('deleteRevision', $revision);
$this->doDeleteRevisionFieldItems($revision);
$this->invokeHook('revision_delete', $revision);
}
}
/**
* Deletes field values of an entity revision from the storage.
*
* @param \Drupal\Core\Entity\ContentEntityInterface $revision
* An entity revision object to be deleted.
*/
protected abstract function doDeleteRevisionFieldItems(ContentEntityInterface $revision);
/**
* Checks translation statuses and invokes the related hooks if needed.
*
* @param \Drupal\Core\Entity\ContentEntityInterface $entity
* The entity being saved.
*/
protected function invokeTranslationHooks(ContentEntityInterface $entity) {
$translations = $entity->getTranslationLanguages(FALSE);
$original_translations = $entity->original
->getTranslationLanguages(FALSE);
$all_translations = array_keys($translations + $original_translations);
// Notify modules of translation insertion/deletion.
foreach ($all_translations as $langcode) {
if (isset($translations[$langcode]) && !isset($original_translations[$langcode])) {
$this->invokeHook('translation_insert', $entity->getTranslation($langcode));
}
elseif (!isset($translations[$langcode]) && isset($original_translations[$langcode])) {
$this->invokeHook('translation_delete', $entity->original
->getTranslation($langcode));
}
}
}
/**
* Invokes hook_entity_storage_load().
*
* @param \Drupal\Core\Entity\ContentEntityInterface[] $entities
* List of entities, keyed on the entity ID.
*/
protected function invokeStorageLoadHook(array &$entities) {
if (!empty($entities)) {
// Call hook_entity_storage_load().
$this->moduleHandler()
->invokeAllWith('entity_storage_load', function (callable $hook, string $module) use (&$entities) {
$hook($entities, $this->entityTypeId);
});
// Call hook_TYPE_storage_load().
$this->moduleHandler()
->invokeAllWith($this->entityTypeId . '_storage_load', function (callable $hook, string $module) use (&$entities) {
$hook($entities);
});
}
}
/**
* {@inheritdoc}
*/
protected function invokeHook($hook, EntityInterface $entity) {
/** @var \Drupal\Core\Entity\ContentEntityInterface $entity */
switch ($hook) {
case 'presave':
$this->invokeFieldMethod('preSave', $entity);
break;
case 'insert':
$this->invokeFieldPostSave($entity, FALSE);
break;
case 'update':
$this->invokeFieldPostSave($entity, TRUE);
break;
}
parent::invokeHook($hook, $entity);
}
/**
* Invokes a method on the Field objects within an entity.
*
* Any argument passed will be forwarded to the invoked method.
*
* @param string $method
* The name of the method to be invoked.
* @param \Drupal\Core\Entity\ContentEntityInterface $entity
* The entity object.
*
* @return array
* A multidimensional associative array of results, keyed by entity
* translation language code and field name.
*/
protected function invokeFieldMethod($method, ContentEntityInterface $entity) {
$result = [];
$args = array_slice(func_get_args(), 2);
$langcodes = array_keys($entity->getTranslationLanguages());
// Ensure that the field method is invoked as first on the current entity
// translation and then on all other translations.
$current_entity_langcode = $entity->language()
->getId();
if (reset($langcodes) != $current_entity_langcode) {
$langcodes = array_diff($langcodes, [
$current_entity_langcode,
]);
array_unshift($langcodes, $current_entity_langcode);
}
foreach ($langcodes as $langcode) {
$translation = $entity->getTranslation($langcode);
// For non translatable fields, there is only one field object instance
// across all translations and it has as parent entity the entity in the
// default entity translation. Therefore field methods on non translatable
// fields should be invoked only on the default entity translation.
$fields = $translation->isDefaultTranslation() ? $translation->getFields() : $translation->getTranslatableFields();
foreach ($fields as $name => $items) {
// call_user_func_array() is way slower than a direct call so we avoid
// using it if have no parameters.
$result[$langcode][$name] = $args ? call_user_func_array([
$items,
$method,
], $args) : $items->{$method}();
}
}
// We need to call the delete method for field items of removed
// translations.
if ($method == 'postSave' && !empty($entity->original)) {
$original_langcodes = array_keys($entity->original
->getTranslationLanguages());
foreach (array_diff($original_langcodes, $langcodes) as $removed_langcode) {
/** @var \Drupal\Core\Entity\ContentEntityInterface $translation */
$translation = $entity->original
->getTranslation($removed_langcode);
// Fields may rely on the isDefaultTranslation() method to determine
// what is going to be deleted - the whole entity or a particular
// translation.
if ($translation->isDefaultTranslation()) {
$translation->setDefaultTranslationEnforced(FALSE);
}
$fields = $translation->getTranslatableFields();
foreach ($fields as $name => $items) {
$items->delete();
}
}
}
return $result;
}
/**
* Invokes the post save method on the Field objects within an entity.
*
* @param \Drupal\Core\Entity\ContentEntityInterface $entity
* The entity object.
* @param bool $update
* Specifies whether the entity is being updated or created.
*/
protected function invokeFieldPostSave(ContentEntityInterface $entity, $update) {
// For each entity translation this returns an array of resave flags keyed
// by field name, thus we merge them to obtain a list of fields to resave.
$resave = [];
foreach ($this->invokeFieldMethod('postSave', $entity, $update) as $translation_results) {
$resave += array_filter($translation_results);
}
if ($resave) {
$this->doSaveFieldItems($entity, array_keys($resave));
}
}
/**
* Checks whether the field values changed compared to the original entity.
*
* @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
* Field definition of field to compare for changes.
* @param \Drupal\Core\Entity\ContentEntityInterface $entity
* Entity to check for field changes.
* @param \Drupal\Core\Entity\ContentEntityInterface $original
* Original entity to compare against.
*
* @return bool
* True if the field value changed from the original entity.
*/
protected function hasFieldValueChanged(FieldDefinitionInterface $field_definition, ContentEntityInterface $entity, ContentEntityInterface $original) {
$field_name = $field_definition->getName();
$langcodes = array_keys($entity->getTranslationLanguages());
if ($langcodes !== array_keys($original->getTranslationLanguages())) {
// If the list of langcodes has changed, we need to save.
return TRUE;
}
foreach ($langcodes as $langcode) {
$items = $entity->getTranslation($langcode)
->get($field_name)
->filterEmptyItems();
$original_items = $original->getTranslation($langcode)
->get($field_name)
->filterEmptyItems();
// If the field items are not equal, we need to save.
if (!$items->equals($original_items)) {
return TRUE;
}
}
return FALSE;
}
/**
* Populates the affected flag for all the revision translations.
*
* @param \Drupal\Core\Entity\ContentEntityInterface $entity
* An entity object being saved.
*/
protected function populateAffectedRevisionTranslations(ContentEntityInterface $entity) {
if ($this->entityType
->isTranslatable() && $this->entityType
->isRevisionable()) {
$languages = $entity->getTranslationLanguages();
foreach ($languages as $langcode => $language) {
$translation = $entity->getTranslation($langcode);
$current_affected = $translation->isRevisionTranslationAffected();
if (!isset($current_affected) || $entity->isNewRevision() && !$translation->isRevisionTranslationAffectedEnforced()) {
// When setting the revision translation affected flag we have to
// explicitly set it to not be enforced. By default it will be
// enforced automatically when being set, which allows us to determine
// if the flag has been already set outside the storage in which case
// we should not recompute it.
// @see \Drupal\Core\Entity\ContentEntityBase::setRevisionTranslationAffected().
$new_affected = $translation->hasTranslationChanges() ? TRUE : NULL;
$translation->setRevisionTranslationAffected($new_affected);
$translation->setRevisionTranslationAffectedEnforced(FALSE);
}
}
}
}
/**
* Ensures integer entity key values are valid.
*
* The identifier sanitization provided by this method has been introduced
* as Drupal used to rely on the database to facilitate this, which worked
* correctly with MySQL but led to errors with other DBMS such as PostgreSQL.
*
* @param array $ids
* The entity key values to verify.
* @param string $entity_key
* (optional) The entity key to sanitize values for. Defaults to 'id'.
*
* @return array
* The sanitized list of entity key values.
*/
protected function cleanIds(array $ids, $entity_key = 'id') {
$definitions = $this->entityFieldManager
->getActiveFieldStorageDefinitions($this->entityTypeId);
$field_name = $this->entityType
->getKey($entity_key);
if ($field_name && $definitions[$field_name]->getType() == 'integer') {
$ids = array_filter($ids, function ($id) {
return is_numeric($id) && $id == (int) $id;
});
$ids = array_map('intval', $ids);
}
return $ids;
}
/**
* Gets entities from the persistent cache backend.
*
* @param array|null &$ids
* If not empty, return entities that match these IDs. IDs that were found
* will be removed from the list.
*
* @return \Drupal\Core\Entity\ContentEntityInterface[]
* Array of entities from the persistent cache.
*/
protected function getFromPersistentCache(?array &$ids = NULL) {
if (!$this->entityType
->isPersistentlyCacheable() || empty($ids)) {
return [];
}
$entities = [];
// Build the list of cache entries to retrieve.
$cid_map = [];
foreach ($ids as $id) {
$cid_map[$id] = $this->buildCacheId($id);
}
$cids = array_values($cid_map);
if ($cache = $this->cacheBackend
->getMultiple($cids)) {
// Get the entities that were found in the cache.
foreach ($ids as $index => $id) {
$cid = $cid_map[$id];
if (isset($cache[$cid])) {
$entities[$id] = $cache[$cid]->data;
unset($ids[$index]);
}
}
}
return $entities;
}
/**
* Stores entities in the persistent cache backend.
*
* @param \Drupal\Core\Entity\ContentEntityInterface[] $entities
* Entities to store in the cache.
*/
protected function setPersistentCache($entities) {
if (!$this->entityType
->isPersistentlyCacheable()) {
return;
}
$cache_tags = [
$this->entityTypeId . '_values',
'entity_field_info',
];
$items = [];
foreach ($entities as $id => $entity) {
$items[$this->buildCacheId($id)] = [
'data' => $entity,
'tags' => $cache_tags,
];
}
$this->cacheBackend
->setMultiple($items);
}
/**
* {@inheritdoc}
*/
public function loadUnchanged($id) {
$entities = [];
$ids = [
$id,
];
// The cache invalidation in the parent has the side effect that loading the
// same entity again during the save process (for example in
// hook_entity_presave()) will load the unchanged entity. Simulate this
// by explicitly removing the entity from the static cache.
parent::resetCache($ids);
// Gather entities from a 'preload' hook. This hook can be used by modules
// that need, for example, to return a different revision than the default
// one for revisionable entity types.
$preloaded_entities = $this->preLoad($ids);
if (!empty($preloaded_entities)) {
$entities += $preloaded_entities;
}
// The default implementation in the parent class unsets the current cache
// and then reloads the entity. That is slow, especially if this is done
// repeatedly in the same request, e.g. when validating and then saving
// an entity. Optimize this for content entities by trying to load them
// directly from the persistent cache again, as in contrast to the static
// cache the persistent one will never be changed until the entity is saved.
$entities += $this->getFromPersistentCache($ids);
if (!$entities) {
$entities[$id] = $this->load($id);
}
else {
// As the entities are put into the persistent cache before the post load
// has been executed we have to execute it if we have retrieved the
// entity directly from the persistent cache.
$this->postLoad($entities);
// As we've removed the entity from the static cache already we have to
// put the loaded unchanged entity there to simulate the behavior of the
// parent.
$this->setStaticCache($entities);
}
return $entities[$id];
}
/**
* Resets the entity cache.
*
* Content entities have both an in-memory static cache and a persistent
* cache. Use this method to clear all caches. To clear just the in-memory
* cache, use the 'entity.memory_cache' service.
*
* @param array $ids
* (optional) If specified, the cache is reset for the entities with the
* given ids only.
*/
public function resetCache(?array $ids = NULL) {
if ($ids) {
parent::resetCache($ids);
if ($this->entityType
->isPersistentlyCacheable()) {
$cids = [];
foreach ($ids as $id) {
unset($this->latestRevisionIds[$id]);
$cids[] = $this->buildCacheId($id);
}
$this->cacheBackend
->deleteMultiple($cids);
}
}
else {
parent::resetCache();
if ($this->entityType
->isPersistentlyCacheable()) {
Cache::invalidateTags([
$this->entityTypeId . '_values',
]);
}
$this->latestRevisionIds = [];
}
}
}
Members
Title Sort descending | Modifiers | Object type | Summary | Overriden Title | Overrides |
---|---|---|---|---|---|
ContentEntityStorageBase::$bundleKey | protected | property | The entity bundle key. | ||
ContentEntityStorageBase::$cacheBackend | protected | property | Cache backend. | ||
ContentEntityStorageBase::$entityFieldManager | protected | property | The entity field manager service. | ||
ContentEntityStorageBase::$entityTypeBundleInfo | protected | property | The entity bundle info. | ||
ContentEntityStorageBase::$latestRevisionIds | protected | property | Stores the latest revision IDs for entities. | ||
ContentEntityStorageBase::cleanIds | protected | function | Ensures integer entity key values are valid. | ||
ContentEntityStorageBase::create | public | function | Constructs a new entity object, without permanently saving it. | Overrides EntityStorageBase::create | 1 |
ContentEntityStorageBase::createInstance | public static | function | Instantiates a new instance of this entity handler. | Overrides EntityHandlerInterface::createInstance | 1 |
ContentEntityStorageBase::createRevision | public | function | Creates a new revision starting off from the specified entity object. | Overrides TranslatableRevisionableStorageInterface::createRevision | |
ContentEntityStorageBase::createTranslation | public | function | Constructs a new entity translation object, without permanently saving it. | Overrides TranslatableStorageInterface::createTranslation | |
ContentEntityStorageBase::createWithSampleValues | public | function | Creates an entity with sample field values. | Overrides ContentEntityStorageInterface::createWithSampleValues | 1 |
ContentEntityStorageBase::deleteRevision | public | function | Deletes a specific entity revision. | Overrides RevisionableStorageInterface::deleteRevision | 1 |
ContentEntityStorageBase::doCreate | protected | function | Performs storage-specific creation of entities. | Overrides EntityStorageBase::doCreate | |
ContentEntityStorageBase::doDelete | protected | function | Performs storage-specific entity deletion. | Overrides EntityStorageBase::doDelete | 1 |
ContentEntityStorageBase::doDeleteFieldItems | abstract protected | function | Deletes entity field values from the storage. | 2 | |
ContentEntityStorageBase::doDeleteRevisionFieldItems | abstract protected | function | Deletes field values of an entity revision from the storage. | 2 | |
ContentEntityStorageBase::doLoadMultipleRevisionsFieldItems | abstract protected | function | Actually loads revision field item values from the storage. | 2 | |
ContentEntityStorageBase::doPostSave | protected | function | Performs post save entity processing. | Overrides EntityStorageBase::doPostSave | |
ContentEntityStorageBase::doPreSave | protected | function | Performs presave entity processing. | Overrides EntityStorageBase::doPreSave | |
ContentEntityStorageBase::doSave | protected | function | Performs storage-specific saving of the entity. | Overrides EntityStorageBase::doSave | 1 |
ContentEntityStorageBase::doSaveFieldItems | abstract protected | function | Writes entity field values to the storage. | 2 | |
ContentEntityStorageBase::finalizePurge | public | function | 1 | ||
ContentEntityStorageBase::getBundleFromClass | public | function | Retrieves the bundle name for a provided class name. | Overrides BundleEntityStorageInterface::getBundleFromClass | |
ContentEntityStorageBase::getBundleFromValues | protected | function | Retrieves the bundle from an array of values. | ||
ContentEntityStorageBase::getEntityClass | public | function | Retrieves the class name used to create the entity. | Overrides EntityStorageBase::getEntityClass | |
ContentEntityStorageBase::getFromPersistentCache | protected | function | Gets entities from the persistent cache backend. | ||
ContentEntityStorageBase::getLatestRevisionId | public | function | Returns the latest revision identifier for an entity. | Overrides RevisionableStorageInterface::getLatestRevisionId | |
ContentEntityStorageBase::getLatestTranslationAffectedRevisionId | public | function | Returns the latest revision affecting the specified translation. | Overrides TranslatableRevisionableStorageInterface::getLatestTranslationAffectedRevisionId | |
ContentEntityStorageBase::getRevisionTranslationMergeSkippedFieldNames | protected | function | Returns an array of field names to skip when merging revision translations. | ||
ContentEntityStorageBase::hasFieldValueChanged | protected | function | Checks whether the field values changed compared to the original entity. | ||
ContentEntityStorageBase::initFieldValues | protected | function | Initializes field values. | ||
ContentEntityStorageBase::invokeFieldMethod | protected | function | Invokes a method on the Field objects within an entity. | ||
ContentEntityStorageBase::invokeFieldPostSave | protected | function | Invokes the post save method on the Field objects within an entity. | ||
ContentEntityStorageBase::invokeHook | protected | function | Invokes a hook on behalf of the entity. | Overrides EntityStorageBase::invokeHook | |
ContentEntityStorageBase::invokeStorageLoadHook | protected | function | Invokes hook_entity_storage_load(). | ||
ContentEntityStorageBase::invokeTranslationHooks | protected | function | Checks translation statuses and invokes the related hooks if needed. | ||
ContentEntityStorageBase::isAnyRevisionTranslated | protected | function | Checks whether any entity revision is translated. | ||
ContentEntityStorageBase::isAnyStoredRevisionTranslated | protected | function | Checks whether any stored entity revision is translated. | ||
ContentEntityStorageBase::loadMultipleRevisions | public | function | Loads multiple entity revisions. | Overrides RevisionableStorageInterface::loadMultipleRevisions | 1 |
ContentEntityStorageBase::loadRevision | public | function | Loads a specific entity revision. | Overrides RevisionableStorageInterface::loadRevision | 1 |
ContentEntityStorageBase::loadUnchanged | public | function | Loads an unchanged entity from the database. | Overrides EntityStorageBase::loadUnchanged | |
ContentEntityStorageBase::onFieldDefinitionCreate | public | function | |||
ContentEntityStorageBase::onFieldDefinitionDelete | public | function | 1 | ||
ContentEntityStorageBase::onFieldDefinitionUpdate | public | function | |||
ContentEntityStorageBase::onFieldStorageDefinitionCreate | public | function | 1 | ||
ContentEntityStorageBase::onFieldStorageDefinitionDelete | public | function | 1 | ||
ContentEntityStorageBase::onFieldStorageDefinitionUpdate | public | function | 1 | ||
ContentEntityStorageBase::populateAffectedRevisionTranslations | protected | function | Populates the affected flag for all the revision translations. | ||
ContentEntityStorageBase::preLoad | protected | function | Gathers entities from a 'preload' step. | Overrides EntityStorageBase::preLoad | |
ContentEntityStorageBase::purgeFieldData | public | function | |||
ContentEntityStorageBase::purgeFieldItems | abstract protected | function | Removes field items from storage per entity during purge. | 2 | |
ContentEntityStorageBase::readFieldItemsToPurge | abstract protected | function | Reads values to be purged for a single field. | 2 | |
ContentEntityStorageBase::resetCache | public | function | Resets the entity cache. | Overrides EntityStorageBase::resetCache | 1 |
ContentEntityStorageBase::setPersistentCache | protected | function | Stores entities in the persistent cache backend. | ||
ContentEntityStorageBase::__construct | public | function | Constructs a ContentEntityStorageBase object. | Overrides EntityStorageBase::__construct | 1 |
DependencySerializationTrait::$_entityStorages | protected | property | |||
DependencySerializationTrait::$_serviceIds | protected | property | |||
DependencySerializationTrait::__sleep | public | function | 1 | ||
DependencySerializationTrait::__wakeup | public | function | 2 | ||
EntityHandlerBase::$moduleHandler | protected | property | The module handler to invoke hooks on. | 5 | |
EntityHandlerBase::moduleHandler | protected | function | Gets the module handler. | 5 | |
EntityHandlerBase::setModuleHandler | public | function | Sets the module handler for this handler. | ||
EntityStorageBase::$baseEntityClass | private | property | Name of the base entity class. | ||
EntityStorageBase::$entityType | protected | property | Information about the entity type. | ||
EntityStorageBase::$entityTypeId | protected | property | Entity type ID for this storage. | ||
EntityStorageBase::$idKey | protected | property | Name of the entity's ID field in the entity database table. | ||
EntityStorageBase::$langcodeKey | protected | property | The name of the entity langcode property. | 1 | |
EntityStorageBase::$memoryCache | protected | property | The memory cache. | ||
EntityStorageBase::$memoryCacheTag | protected | property | The memory cache tag. | ||
EntityStorageBase::$uuidKey | protected | property | Name of entity's UUID database table field, if it supports UUIDs. | 1 | |
EntityStorageBase::$uuidService | protected | property | The UUID service. | 1 | |
EntityStorageBase::buildCacheId | protected | function | Builds the cache ID for the passed in entity ID. | 1 | |
EntityStorageBase::buildPropertyQuery | protected | function | Builds an entity query. | 1 | |
EntityStorageBase::delete | public | function | Deletes permanently saved entities. | Overrides EntityStorageInterface::delete | 2 |
EntityStorageBase::doLoadMultiple | abstract protected | function | Performs storage-specific loading of entities. | 4 | |
EntityStorageBase::getAggregateQuery | public | function | Gets an aggregated query instance. | Overrides EntityStorageInterface::getAggregateQuery | |
EntityStorageBase::getEntitiesByClass | protected | function | Indexes the given array of entities by their class name and ID. | ||
EntityStorageBase::getEntityType | public | function | Gets the entity type definition. | Overrides EntityStorageInterface::getEntityType | |
EntityStorageBase::getEntityTypeId | public | function | Gets the entity type ID. | Overrides EntityStorageInterface::getEntityTypeId | |
EntityStorageBase::getFromStaticCache | protected | function | Gets entities from the static cache. | ||
EntityStorageBase::getQuery | public | function | Gets an entity query instance. | Overrides EntityStorageInterface::getQuery | |
EntityStorageBase::getQueryServiceName | abstract protected | function | Gets the name of the service for the query for this entity storage. | 4 | |
EntityStorageBase::has | abstract protected | function | Determines if this entity already exists in storage. | 4 | |
EntityStorageBase::hasData | public | function | Determines if the storage contains any data. | Overrides EntityStorageInterface::hasData | 3 |
EntityStorageBase::load | public | function | Loads one entity. | Overrides EntityStorageInterface::load | 2 |
EntityStorageBase::loadByProperties | public | function | Load entities by their property values without any access checks. | Overrides EntityStorageInterface::loadByProperties | 3 |
EntityStorageBase::loadMultiple | public | function | Loads one or more entities. | Overrides EntityStorageInterface::loadMultiple | 1 |
EntityStorageBase::mapFromStorageRecords | protected | function | Maps from storage records to entity objects. | 4 | |
EntityStorageBase::postLoad | protected | function | Attaches data to entities upon loading. | ||
EntityStorageBase::restore | public | function | Restores a previously saved entity. | Overrides EntityStorageInterface::restore | 1 |
EntityStorageBase::save | public | function | Saves the entity permanently. | Overrides EntityStorageInterface::save | 4 |
EntityStorageBase::setStaticCache | protected | function | Stores entities in the static entity cache. | ||
EntityStorageInterface::FIELD_LOAD_CURRENT | constant | Load the most recent version of an entity's field data. | |||
EntityStorageInterface::FIELD_LOAD_REVISION | constant | Load the version of an entity's field data specified in the entity. | |||
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.