trait SerializedColumnNormalizerTrait

trait SerializedColumnNormalizerTrait {
    
    /**
     * Checks if there is a serialized string for a column.
     *
     * @param mixed $data
     *   The field item data to denormalize.
     * @param string $class
     *   The expected class to instantiate.
     * @param \Drupal\Core\Field\FieldItemInterface $field_item
     *   The field item.
     */
    protected function checkForSerializedStrings($data, $class, FieldItemInterface $field_item) {
        // Require specialized denormalizers for fields with 'serialize' columns.
        // Note: this cannot be checked in ::supportsDenormalization() because at
        // that time we only have the field item class. ::hasSerializeColumn()
        // must be able to call $field_item->schema(), which requires a field
        // storage definition. To determine that, the entity type and bundle
        // must be known, which is contextual information that the Symfony
        // serializer does not pass to ::supportsDenormalization().
        if (!is_array($data)) {
            $data = [
                $field_item->getDataDefinition()
                    ->getMainPropertyName() => $data,
            ];
        }
        if ($this->dataHasStringForSerializeColumn($field_item, $data)) {
            $field_name = $field_item->getParent() ? $field_item->getParent()
                ->getName() : $field_item->getName();
            throw new \LogicException(sprintf('The generic FieldItemNormalizer cannot denormalize string values for "%s" properties of the "%s" field (field item class: %s).', implode('", "', $this->getSerializedPropertyNames($field_item)), $field_name, $class));
        }
    }
    
    /**
     * Checks if the data contains string value for serialize column.
     *
     * @param \Drupal\Core\Field\FieldItemInterface $field_item
     *   The field item.
     * @param array $data
     *   The data being denormalized.
     *
     * @return bool
     *   TRUE if there is a string value for serialize column, otherwise FALSE.
     */
    protected function dataHasStringForSerializeColumn(FieldItemInterface $field_item, array $data) {
        foreach ($this->getSerializedPropertyNames($field_item) as $property_name) {
            if (isset($data[$property_name]) && is_string($data[$property_name])) {
                return TRUE;
            }
        }
        return FALSE;
    }
    
    /**
     * Gets the names of all serialized properties.
     *
     * @param \Drupal\Core\Field\FieldItemInterface $field_item
     *   The field item.
     *
     * @return string[]
     *   The property names for serialized properties.
     */
    protected function getSerializedPropertyNames(FieldItemInterface $field_item) {
        $field_storage_definition = $field_item->getFieldDefinition()
            ->getFieldStorageDefinition();
        if ($custom_property_names = $this->getCustomSerializedPropertyNames($field_item)) {
            return $custom_property_names;
        }
        $field_storage_schema = $field_item->schema($field_storage_definition);
        // If there are no columns then there are no serialized properties.
        if (!isset($field_storage_schema['columns'])) {
            return [];
        }
        $serialized_columns = array_filter($field_storage_schema['columns'], function ($column_schema) {
            return isset($column_schema['serialize']) && $column_schema['serialize'] === TRUE;
        });
        return array_keys($serialized_columns);
    }
    
    /**
     * Gets the names of all properties the plugin treats as serialized data.
     *
     * This allows the field storage definition or entity type to provide a
     * setting for serialized properties. This can be used for fields that
     * handle serialized data themselves and do not rely on the serialized schema
     * flag.
     *
     * @param \Drupal\Core\Field\FieldItemInterface $field_item
     *   The field item.
     *
     * @return string[]
     *   The property names for serialized properties.
     */
    protected function getCustomSerializedPropertyNames(FieldItemInterface $field_item) {
        if ($field_item instanceof PluginInspectionInterface) {
            $definition = $field_item->getPluginDefinition();
            $serialized_fields = $field_item->getEntity()
                ->getEntityType()
                ->get('serialized_field_property_names');
            $field_name = $field_item->getFieldDefinition()
                ->getName();
            if (is_array($serialized_fields) && isset($serialized_fields[$field_name]) && is_array($serialized_fields[$field_name])) {
                return $serialized_fields[$field_name];
            }
            if (isset($definition['serialized_property_names']) && is_array($definition['serialized_property_names'])) {
                return $definition['serialized_property_names'];
            }
        }
        return [];
    }

}