FieldStorageConfig

Sets cacheability; useful for value object constructors.

{@inheritdoc}

{@inheritdoc}

{@inheritdoc}

{@inheritdoc}

{@inheritdoc}

{@inheritdoc}

{@inheritdoc}

Implements the magic __sleep() method.

Using the Serialize interface and serialize() / unserialize() methods breaks entity forms in PHP 5.4.

Investigate in https://www.drupal.org/node/1977206.

{@inheritdoc}

Constructs a FieldStorageConfig object.

In most cases, Field entities are created via FieldStorageConfig::create($values)), where $values is the same parameter as in this constructor.

Gets the entity type manager.

Gets the entity type bundle info service.

Gets the language manager.

Gets the UUID generator.

Gets the identifier.

Gets the entity UUID (Universally Unique Identifier).

The UUID is guaranteed to be unique and can be used to identify an entity across multiple systems.

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.

Enforces an entity to be new.

Allows migrations to create entities with pre-defined IDs by forcing the entity to be new before saving.

Gets the ID of the type of the entity.

Gets the bundle of the entity.

Gets the label of the entity.

Gets the URL object for the entity.

The entity must have an id already. Content entities usually get their IDs by saving them.

URI templates might be set in the links array in an annotation, for example:

Indicates if a link template exists for a given key.

Gets an array link templates.

Generates the HTML for a link to this entity.

Gets an array of placeholders for this entity.

Individual entity classes may override this method to add additional placeholders if desired. If so, they should be sure to replicate the property caching logic.

Gets a list of URI relationships supported by this entity.

Checks data value access.

Gets the language of the entity.

Saves an entity permanently.

When saving existing entities, the entity is assumed to be complete, partial updates of entities are not supported.

Deletes an entity permanently.

Creates a duplicate of the entity.

Gets the entity type definition.

Overrides \Drupal\Core\Entity\Entity::preSave().

Acts on a saved entity before the insert or update hook is invoked.

Used after the entity is saved, but before invoking the insert or update hook. Note that in case of translatable content entities this callback is only fired on their current translation. It is up to the developer to iterate over all translations if needed.

Changes the values of an entity before it is created.

Load defaults for example.

Acts on a created entity before hooks are invoked.

Used after the entity is created, but before saving the entity and before any of the presave hooks are invoked.

See the @link entity_crud Entity CRUD topic @endlink for more information.

Acts on entities before they are deleted and before hooks are invoked.

Used before the entities are deleted and before invoking the delete hook.

Acts on deleted entities before the delete hook is invoked.

Used after the entities are deleted but before invoking the delete hook.

Acts on loaded entities.

Gets a list of entities referenced by this entity.

The list cache tags to invalidate for this entity.

Returns the cache tags that should be used to invalidate caches.

This will not return additional cache tags added through addCacheTags().

Loads an entity.

Loads one or more entities.

Constructs a new entity object, without permanently saving it.

Invalidates an entity's cache tags upon save.

Invalidates an entity's cache tags upon delete.

Gets the original ID.

Sets the original ID.

Gets an array of all property values.

Gets a typed data object for this entity object.

The returned typed data object wraps this entity and allows dealing with entities based on the generic typed data API.

Gets the key that is used to store configuration dependencies.

Gets the configuration dependency name.

Configuration entities can depend on content and configuration entities. They store an array of content and config dependency names in their "dependencies" key.

Gets the configuration target identifier for the entity.

Used to supply the correct format for storing a reference targeting this entity in configuration.

Adds a dependency.

Adds multiple dependencies.

Calculates and returns dependencies of a specific plugin instance.

Dependencies are added for the module that provides the plugin, as well as any dependencies declared by the instance's calculateDependencies() method, if it implements \Drupal\Component\Plugin\DependentPluginInterface.

Calculates and adds dependencies of a specific plugin instance.

Dependencies are added for the module that provides the plugin, as well as any dependencies declared by the instance's calculateDependencies() method, if it implements \Drupal\Component\Plugin\DependentPluginInterface.

Wraps the module handler.

Wraps the theme handler.

{@inheritdoc}

{@inheritdoc}

Returns the value of a property.

Sets the value of a property.

Enables the configuration entity.

Disables the configuration entity.

Sets the status of the configuration entity.

Returns whether the configuration entity is enabled.

Status implementations for configuration entities should follow these general rules:

• Status does not affect the loading of entities. I.e. Disabling configuration entities should only have UI/access implications.
• It should only take effect when a 'status' key is explicitly declared in the entity_keys info of a configuration entity's annotation data.
• Each entity implementation (entity/controller) is responsible for checking and managing the status.

{@inheritdoc}

Returns whether this entity is being changed during the uninstall process.

If you are writing code that responds to a change in this entity (insert, update, delete, presave, etc.), and your code would result in a configuration change (whether related to this configuration entity, another configuration entity, or non-entity configuration) or your code would result in a change to this entity itself, you need to check and see if this entity change is part of an uninstall process, and skip executing your code if that is the case.

For example, \Drupal\language\Entity\ConfigurableLanguage::preDelete() prevents the API from deleting the default language. However during an uninstall of the language module it is expected that the default language should be deleted.

Helper callback for uasort() to sort configuration entities by weight and label.

Gets the typed config manager.

Calculates dependencies and stores them in the dependency property.

Gets the configuration dependencies.

Informs the entity that entities it depends on will be deleted.

This method allows configuration entities to remove dependencies instead of being deleted themselves. Configuration entities can use this method to avoid being unnecessarily deleted during an extension uninstallation. For example, entity displays remove references to widgets and formatters if the plugin that supplies them depends on a module that is being uninstalled.

If this method returns TRUE then the entity needs to be re-saved by the caller for the changes to take effect. Implementations should not save the entity.

Sets the value of a third-party setting.

Gets the value of a third-party setting.

Gets all third-party settings of a given module.

Unsets a third-party setting.

Gets the list of third parties that store information.

Gets the configuration manager.

Checks whether this entity is installable.

For example, a default view might not be installable if the base table doesn't exist.

Sets that the data should be trusted.

If the data is trusted then dependencies will not be calculated on save and schema will not be used to cast the values. Generally this is only used during module and theme installation. Once the config entity has been saved the data will no longer be marked as trusted. This is an optimization for creation of configuration during installation.

Gets whether on not the data is trusted.

Prepares saving a new field definition.

Prepares saving an updated field definition.

Returns the field schema.

Note that this method returns an empty array for computed fields which have no schema.

Returns the storage behavior for this field.

Indicates whether the entity type's storage should take care of storing the field values or whether it is handled separately; e.g. by the module providing the field.

Determines whether the field is a base field.

Base fields are not specific to a given bundle or a set of bundles. This excludes configurable fields, as they are always attached to a specific bundle.

Returns the field columns, as defined in the field schema.

Returns the list of bundles where the field storage has fields.

Returns the machine name of the field.

This defines how the field data is accessed from the entity. For example, if the field name is "foo", then $entity->foo returns its data.

Returns whether the field is deleted or not.

Returns the name of the module providing the field type.

Returns the field type.

Returns the storage settings.

Each field type defines the settings that are meaningful for that type. For example, a text field can define a 'max_length' setting, and an image field can define an 'alt_field_required' setting.

The method always returns an array of all available settings for this field type, possibly with the default values merged in if values have not been provided for all available settings.

Returns the value of a given storage setting.

Sets the value for a field setting by name.

Sets field storage settings.

Note that the method does not unset existing settings not specified in the incoming $settings array.

For example:

Returns whether the field supports translation.

Returns whether the field storage is revisionable.

Note that if the entity type is revisionable and the field storage has a cardinality higher than 1, the field storage is considered revisionable by default.

Sets whether the field is translatable.

Returns the name of the provider of this field.

Returns the human-readable label for the field.

Returns the human-readable description for the field.

This is displayed in addition to the label in places where additional descriptive information is helpful. For example, as help text below the form element in entity edit forms.

Returns the maximum number of items allowed for the field.

Possible values are positive integers or FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED.

Sets the maximum number of items allowed for the field.

Gets an options provider for the given field item property.

Returns whether the field can contain multiple items.

Returns whether the field storage is locked or not.

Sets the locked flag.

Returns the ID of the entity type the field is attached to.

This method should not be confused with EntityInterface::getEntityTypeId() (configurable fields are config entities, and thus implement both interfaces):

• FieldStorageDefinitionInterface::getTargetEntityTypeId() answers "as a field storage, which entity type are you attached to?".
• EntityInterface::getEntityTypeId() answers "as a (config) entity, what is your own entity type?".

Determines whether a field has any data.

Returns an array of validation constraints.

See \Drupal\Core\TypedData\DataDefinitionInterface::getConstraints() for details.

Returns a validation constraint.

See \Drupal\Core\TypedData\DataDefinitionInterface::getConstraints() for details.

Gets the definition of a contained property.

Gets an array of property definitions of contained properties.

Returns the names of the field's subproperties.

A field is a list of items, and each item can contain one or more properties. All items for a given field contain the same property names, but the values can be different for each item.

For example, an email field might just contain a single 'value' property, while a link field might contain 'title' and 'url' properties, and a text field might contain 'value', 'summary', and 'format' properties.

Returns the name of the main property, if any.

Some field items consist mainly of one main property, e.g. the value of a text field or the @code target_id @endcode of an entity reference. If the field item has no main property, the method returns NULL.

Returns a unique identifier for the field storage.

Helper to retrieve the field item class.

Loads a field config entity based on the entity type and field name.

Checks if the field storage can be deleted.

Returns the custom storage indexes for the field data storage.

Sets the custom storage indexes for the field data storage.

.