FieldConfigInterface

Creates a new data definition object.

This method is typically used by \Drupal\Core\TypedData\TypedDataManager::createDataDefinition() to build a definition object for an arbitrary data type. When the definition class is known, it is recommended to directly use the static create() method on that class instead; e.g.:

Returns the data type of the data.

Returns a human readable label.

Returns a human readable description.

Descriptions are usually used on user interfaces where the data is edited or displayed.

Returns whether the data is multi-valued, i.e. a list of data items.

This is equivalent to checking whether the data definition implements the \Drupal\Core\TypedData\ListDefinitionInterface interface.

Determines whether the data is read-only.

Determines whether the data value is computed.

For example, data could be computed depending on some other values.

Determines whether a data value is required.

For required data a non-NULL value is mandatory.

Returns the class used for creating the typed data object.

If not specified, the default class of the data type will be returned.

Returns the array of settings, as required by the used class.

See the documentation of the class for supported or required settings.

Returns the value of a given setting.

Returns an array of validation constraints.

The validation constraints of a definition consist of any for it defined constraints and default constraints, which are generated based on the definition and its data type. See \Drupal\Core\TypedData\TypedDataManager::getDefaultConstraints().

Constraints are defined via an array, having constraint plugin IDs as key and constraint options as values, e.g.

Returns a validation constraint.

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

Adds a validation constraint to the FieldItemList.

Note: If you wish to apply a constraint to just a property of a FieldItem use \Drupal\Core\Field\FieldConfigInterface::addPropertyConstraints() instead.

Determines whether the data value is internal.

This can be used in a scenario when it is not desirable to expose this data value to an external system.

The implications of this method are left to the discretion of the caller. For example, a module providing an HTTP API may not expose entities of this type, or a custom entity reference field settings form may deprioritize entities of this type in a select list.

Creates a new list data definition for items of the given data type.

This method is typically used by \Drupal\Core\TypedData\TypedDataManager::createListDataDefinition() to build a definition object for an arbitrary item type. When the definition class is known, it is recommended to directly use the static create() method on that class instead; e.g.:

Gets the data definition of an item of the list.

The cache contexts associated with this object.

These identify a specific variation/representation of the object.

Cache contexts are tokens: placeholders that are converted to cache keys by the @cache_contexts_manager service. The replacement value depends on the request context (the current URL, language, and so on). They're converted before storing an object in cache.

The cache tags associated with this object.

When this object is modified, these cache tags will be invalidated.

The maximum age for which this object may be cached.

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 the field type.

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):

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

Gets the bundle the field is attached to.

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

• FieldDefinitionInterface::getTargetBundle() answers "as a field, which bundle are you attached to?".
• EntityInterface::bundle() answers "as a (config) entity, what is your own bundle?" (not relevant in our case, the config entity types used to store the definitions of configurable fields do not have bundles).

Returns whether the display for the field can be configured.

Returns the default display options for the field.

If the field's display is configurable, the returned display options act as default values and may be overridden via the respective entity display. Otherwise, the display options will be applied to entity displays as is.

Returns the default value literal for the field.

This method retrieves the raw property assigned to the field definition. When computing the runtime default value for a field in a given entity, ::getDefaultValue() should be used instead.

Returns the default value callback for the field.

This method retrieves the raw property assigned to the field definition. When computing the runtime default value for a field in a given entity, ::getDefaultValue() should be used instead.

Returns the default value for the field in a newly created entity.

This method computes the runtime default value for a field in a given entity. To access the raw properties assigned to the field definition, ::getDefaultValueLiteral() or ::getDefaultValueCallback() should be used instead.

Returns whether the field is translatable.

Returns the field storage definition.

Gets an object that can be saved in configuration.

Base fields are defined in code. In order to configure field definition properties per bundle use this method to create an override that can be saved in configuration.

Returns a unique identifier for the field.

Checks data value access.

Adds cache contexts.

Adds cache tags.

Merges the maximum age (in seconds) with the existing maximum age.

The max age will be set to the given value if it is lower than the existing value.

Adds a dependency on an object: merges its cacheability metadata.

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.

Gets the identifier.

Gets the language of the entity.

Determines whether the entity is new.

Usually an entity is new if no ID exists for it yet. However, entities may be enforced to be new with existing IDs too.

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:

Generates the HTML for a link to this entity.

Indicates if a link template exists for a given key.

Gets a list of URI relationships supported by this entity.

Loads an entity.

Loads one or more entities.

Constructs a new entity object, without permanently saving it.

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.

Acts on an entity before the presave hook is invoked.

Used before the entity is saved and before invoking the presave 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. This is different from its counterpart in the Field API, FieldItemListInterface::preSave(), which is fired on all field translations automatically.

Adjust existing implementations and the documentation according to https://www.drupal.org/node/2577609 to have a consistent API.

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.

Creates a duplicate of the entity.

Gets the entity type definition.

Gets a list of entities referenced by this entity.

Gets the original ID.

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

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

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.

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.

Sets the status of the synchronization flag.

Returns whether this entity is being changed as part of a synchronization.

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 change to this entity itself, a configuration change (whether related to this entity, another entity, or non-entity configuration), you need to check and see if this entity change is part of a synchronization process, and skip executing your code if that is the case.

For example, \Drupal\node\Entity\NodeType::postSave() adds the default body field to newly created node type configuration entities, which is a configuration change. You would not want this code to run during an import, because imported entities were already given the body field when they were originally created, and the imported configuration includes all of their currently-configured fields. On the other hand, \Drupal\field\Entity\FieldStorageConfig::preSave() and the methods it calls make sure that the storage tables are created or updated for the field storage configuration entity, which is not a configuration change, and it must be done whether due to an import or not. So, the first method should check $entity->isSyncing() and skip executing if it returns TRUE, and the second should not perform this check.

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.

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.

Returns the value of a property.

Sets the value of a property.

Calculates dependencies and stores them in the dependency property.

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.

Gets the configuration dependencies.

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.

Sets the field definition label.

Sets a human readable description.

Descriptions are usually used on user interfaces where the data is edited or displayed.

Sets whether the field is translatable.

Sets field settings.

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

For example:

Sets the value for a field setting by name.

Sets whether the field can be empty.

If a field is required, an entity needs to have at least a valid, non-empty item in that field's FieldItemList in order to pass validation.

An item is considered empty if its isEmpty() method returns TRUE. Typically, that is if at least one of its required properties is empty.

Sets a default value.

Note that if a default value callback is set, it will take precedence over any value set here.

Sets a custom default value callback.

If set, the callback overrides any set default value.

Sets constraints for a given field item property.

Note: this overwrites any existing property constraints. If you need to add to the existing constraints, use \Drupal\Core\Field\FieldConfigInterface::addPropertyConstraints()

Note that constraints added via this method are not stored in configuration and as such need to be added at runtime using hook_entity_bundle_field_info_alter().

Adds constraints for a given field item property.

Adds a constraint to a property of a field item. e.g.

Sets the array of validation constraints for the FieldItemList.

NOTE: This will overwrite any previously set constraints. In most cases FieldConfigInterface::addConstraint() should be used instead.

Note that constraints added via this method are not stored in configuration and as such need to be added at runtime using hook_entity_bundle_field_info_alter().