getPropertyDefinitions example

  public function getConstraint($constraint_name) {
    return NULL;
  }

  /** * {@inheritdoc} */
  public function getPropertyDefinition($name) {
    if (!isset($this->propertyDefinitions)) {
      $this->getPropertyDefinitions();
    }
    if (isset($this->propertyDefinitions[$name])) {
      return $this->propertyDefinitions[$name];
    }
  }

  /** * {@inheritdoc} */
  public function getPropertyDefinitions() {
    if (!isset($this->propertyDefinitions)) {
      

  protected static function decorateResourceIdentifierWithDrupalInternalTargetId($field, array $resource_identifier): array {
    $property_definitions = $field->getFieldDefinition()->getFieldStorageDefinition()->getPropertyDefinitions();

    if (!isset($property_definitions['target_id'])) {
      return $resource_identifier;
    }

    $is_data_reference_definition = $property_definitions['target_id'] instanceof DataReferenceTargetDefinition;
    if ($is_data_reference_definition) {
      // Numeric target IDs usually reference content entities, which use an       // auto-incrementing integer ID. Non-numeric target IDs usually reference       // config entities, which use a machine-name as an ID.       $resource_identifier['meta']['drupal_internal__target_id'] = is_numeric($field->target_id)
        ?

return \Drupal::service('plugin.manager.field.field_type')->createFieldItem($items, 0);
    }
    // @todo: Allow setting custom options provider, see     // https://www.drupal.org/node/2002138.   }

  /** * {@inheritdoc} */
  public function getPropertyDefinition($name) {
    if (!isset($this->propertyDefinitions)) {
      $this->getPropertyDefinitions();
    }
    if (isset($this->propertyDefinitions[$name])) {
      return $this->propertyDefinitions[$name];
    }
  }

  /** * {@inheritdoc} */
  public function getPropertyDefinitions() {
    if (!isset($this->propertyDefinitions)) {
      

if ($count1 !== $count2) {
      // One of them is empty but not the other one so the value changed.       return FALSE;
    }
    $value1 = $this->getValue();
    $value2 = $list_to_compare->getValue();
    if ($value1 === $value2) {
      return TRUE;
    }
    // If the values are not equal ensure a consistent order of field item     // properties and remove properties which will not be saved.     $property_definitions = $this->getFieldDefinition()->getFieldStorageDefinition()->getPropertyDefinitions();
    $non_computed_properties = array_filter($property_definitions, function DDataDefinitionInterface $property) {
      return !$property->isComputed();
    });
    $callback = function D&$value) use ($non_computed_properties) {
      if (is_array($value)) {
        $value = array_intersect_key($value, $non_computed_properties);

        // Also filter out properties with a NULL value as they might exist in         // one field item and not in the other, depending on how the values are         // set. Do not filter out empty strings or other false-y values as e.g.         // a NULL or FALSE in a boolean field is not the same.

protected $propertyDefinitions;

  /** * {@inheritdoc} */
  abstract public function getPropertyDefinitions();

  /** * {@inheritdoc} */
  public function getPropertyDefinition($name) {
    $definitions = $this->getPropertyDefinitions();
    if (isset($definitions[$name])) {
      return $definitions[$name];
    }
  }

  /** * {@inheritdoc} */
  public function getMainPropertyName() {
    return NULL;
  }

  

  public function isEmpty() {
    $value = $this->get('value')->getValue();
    return $value === NULL || $value === '';
  }

  /** * {@inheritdoc} */
  public function onChange($property_name, $notify = TRUE) {
    // Unset processed properties that are affected by the change.     foreach ($this->definition->getPropertyDefinitions() as $property => $definition) {
      if ($definition->getClass() == '\Drupal\text\TextProcessed') {
        if ($property_name == 'format' || ($definition->getSetting('text source') == $property_name)) {
          $this->writePropertyValue($property, NULL);
        }
      }
    }
    parent::onChange($property_name, $notify);
  }

  /** * {@inheritdoc} */

    $field_manager->useCaches(FALSE);
    $field_manager->useCaches(TRUE);

    // Serialize the ViewExecutable as part of other data.     unserialize(serialize(['SOMETHING UNEXPECTED', $view_executable]));

    // Make sure the serialization of the ViewExecutable didn't influence the     // field definitions.     $nid_definition_after = $field_manager->getBaseFieldDefinitions('node')['nid']
      ->getItemDefinition()
      ->getFieldDefinition();
    $this->assertEquals($nid_definition_before->getPropertyDefinitions(), $nid_definition_after->getPropertyDefinitions());
  }

  /** * Tests if argument overrides by validators are propagated to tokens. */
  public function testArgumentValidatorValueOverride() {
    $view = Views::getView('test_argument_dependency');
    $view->setDisplay('page_1');
    $view->setArguments(['1', 'this value should be replaced']);
    $view->execute();
    $expected = [
      

public static function mainPropertyName() {
    return 'value';
  }

  /** * {@inheritdoc} */
  public function __construct(ComplexDataDefinitionInterface $definition, $name = NULL, TypedDataInterface $parent = NULL) {
    parent::__construct($definition, $name, $parent);
    // Initialize computed properties by default, such that they get cloned     // with the whole item.     foreach ($this->definition->getPropertyDefinitions() as $name => $definition) {
      if ($definition->isComputed()) {
        $this->properties[$name] = \Drupal::typedDataManager()->getPropertyInstance($this, $name);
      }
    }
  }

  /** * {@inheritdoc} */
  public function getEntity() {
    return $this->getParent()->getEntity();
  }

/** * Helper method to determine which field item property contains an entity. * * @param \Drupal\Core\Field\Plugin\Field\FieldType\EntityReferenceItem $item * The entity reference item for which to determine the entity property * name. * * @return string * The property name which has an entity as its value. */
  protected static function getDataReferencePropertyName(EntityReferenceItem $item) {
    foreach ($item->getDataDefinition()->getPropertyDefinitions() as $property_name => $property_definition) {
      if ($property_definition instanceof DataReferenceDefinitionInterface) {
        return $property_name;
      }
    }
  }

  /** * Creates a ResourceIdentifier for a NULL or FALSE entity reference item. * * @param \Drupal\Core\Field\Plugin\Field\FieldType\EntityReferenceItem $item * The entity reference field item. * * @return self * A new ResourceIdentifier object. */

// Check that the image item can be set to the referenced file directly.     $entity->image_test = $this->image;
    $this->assertEquals($this->image->id(), $entity->image_test->target_id);

    // Delete the image and try to save the entity again.     $this->image->delete();
    $entity = EntityTest::create(['name' => $this->randomMachineName()]);
    $entity->save();

    // Test image item properties.     $expected = ['target_id', 'entity', 'alt', 'title', 'width', 'height'];
    $properties = $entity->getFieldDefinition('image_test')->getFieldStorageDefinition()->getPropertyDefinitions();
    $this->assertEquals($expected, array_keys($properties));

  }

  /** * Tests generateSampleItems() method under different resolutions. */
  public function testImageItemSampleValueGeneration() {

    // Default behaviour. No resolution configuration.     $entity = EntityTest::create();
    

$message .= ' ' . $reason;
          }
          throw new CacheableAccessDeniedHttpException($cacheability, $message);
        }
      }

      // Get all of the referenceable resource types.       $resource_types = $this->getRelatableResourceTypes($resource_types, $candidate_definitions);

      $at_least_one_entity_reference_field = FALSE;
      $candidate_property_names = array_unique(NestedArray::mergeDeepArray(array_map(function DFieldItemDataDefinitionInterface $definition) use (&$at_least_one_entity_reference_field) {
        $property_definitions = $definition->getPropertyDefinitions();
        return array_reduce(array_keys($property_definitions), function D$property_names, $property_name) use ($property_definitions, &$at_least_one_entity_reference_field) {
          $property_definition = $property_definitions[$property_name];
          $is_data_reference_definition = $property_definition instanceof DataReferenceTargetDefinition;
          if (!$property_definition->isInternal()) {
            // Entity reference fields are special: their reference property             // (usually `target_id`) is exposed in the JSON:API representation             // with a prefix.             $property_names[] = $is_data_reference_definition ? 'id' : $property_name;
          }
          if ($is_data_reference_definition) {
            $at_least_one_entity_reference_field = TRUE;
            

/** * {@inheritdoc} */
  public function denormalize($data, $class, $format = NULL, array $context = []): mixed {
    $item_definition = $context['field_definition']->getItemDefinition();
    assert($item_definition instanceof FieldItemDataDefinitionInterface);

    $field_item = $this->getFieldItemInstance($context['resource_type'], $item_definition);
    $this->checkForSerializedStrings($data, $class, $field_item);

    $property_definitions = $item_definition->getPropertyDefinitions();

    $serialized_property_names = $this->getCustomSerializedPropertyNames($field_item);
    $denormalize_property = function D$property_name, $property_value, $property_value_class, $format, $context) use ($serialized_property_names) {
      if ($this->serializer->supportsDenormalization($property_value, $property_value_class, $format, $context)) {
        return $this->serializer->denormalize($property_value, $property_value_class, $format, $context);
      }
      else {
        if (in_array($property_name, $serialized_property_names, TRUE)) {
          $property_value = serialize($property_value);
        }
        return $property_value;
      }

  protected function constructValue($data, $context) {
    $field_item = $context['target_instance'];

    // Get the property definitions.     assert($field_item instanceof FieldItemInterface);
    $field_definition = $field_item->getFieldDefinition();
    $item_definition = $field_definition->getItemDefinition();
    assert($item_definition instanceof FieldItemDataDefinitionInterface);
    $property_definitions = $item_definition->getPropertyDefinitions();

    $serialized_property_names = $this->getCustomSerializedPropertyNames($field_item);
    $denormalize_property = function D$property_name, $property_value, $property_value_class, $context) use ($serialized_property_names) {
      if ($this->serializer->supportsDenormalization($property_value, $property_value_class, NULL, $context)) {
        return $this->serializer->denormalize($property_value, $property_value_class, NULL, $context);
      }
      else {
        if (in_array($property_name, $serialized_property_names, TRUE)) {
          $property_value = serialize($property_value);
        }
        return $property_value;
      }

      ],
      'primary key' => ['entity_id', 'deleted', 'delta', 'langcode'],
      'indexes' => [
        'bundle' => ['bundle'],
        'revision_id' => ['revision_id'],
      ],
    ];

    // Check that the schema does not include forbidden column names.     $schema = $storage_definition->getSchema();
    $properties = $storage_definition->getPropertyDefinitions();
    $table_mapping = $this->getTableMapping($entity_type, [$storage_definition]);
    if (array_intersect(array_keys($schema['columns']), $table_mapping->getReservedColumns())) {
      throw new FieldException("Illegal field column names on {$storage_definition->getName()}");
    }

    // Add field columns.     foreach ($schema['columns'] as $column_name => $attributes) {
      $real_name = $table_mapping->getFieldColumnName($storage_definition, $column_name);
      $data_schema['fields'][$real_name] = $attributes;
      // A dedicated table only contain rows for actual field values, and no       // rows for entities where the field is empty. Thus, we can safely

$typed_data = $this->createTypedData($definition, $value);

    // Test iterating.     $count = 0;
    foreach ($typed_data as $item) {
      $this->assertInstanceOf(TypedDataInterface::class, $item);
      $count++;
    }
    $this->assertEquals(3, $count);

    // Test retrieving metadata.     $this->assertEquals(array_keys($value), array_keys($typed_data->getDataDefinition()->getPropertyDefinitions()));
    $definition = $typed_data->getDataDefinition()->getPropertyDefinition('one');
    $this->assertEquals('string', $definition->getDataType());
    $this->assertNull($typed_data->getDataDefinition()->getPropertyDefinition('invalid'));

    // Test getting and setting properties.     $this->assertEquals('eins', $typed_data->get('one')->getValue());
    $this->assertEquals($value, $typed_data->toArray());
    $typed_data->set('one', 'uno');
    $this->assertEquals('uno', $typed_data->get('one')->getValue());
    // Make sure the update is reflected in the value of the map also.     $value = $typed_data->getValue();