Returns parsed field value.

@param \eZ\Publish\API\Repository\Values\Content\Field $field
@param \eZ\Publish\API\Repository\Values\Content\Content $content
@param string $language
@param string $imageFieldIdentifier
@param array $options

@return mixed
328800
private function getParsedFieldValue(Field $field, Content $content, $language, $imageFieldIdentifier, $options = [])
    {
        try {
            $this->logger->debug(sprintf(
                'Fetching field content for contentId %s, fieldId %s, fieldName %s',
                $content->id,
                $field->id,
                $field->fieldDefIdentifier
            ));

            $fieldType = $this->fieldDefIdentifiers[$field->fieldDefIdentifier];

            return $this->typeValue->$fieldType($field, $content, $language, $imageFieldIdentifier, $options);
        } catch (Exception $e) {
            $this->logger->warning(sprintf(
                'Unable to fetch field content for contentId %s, fieldId %s, fieldName %s (original exception: %s)',
                $content->id,
                $field->id,
                $field->fieldDefIdentifier,
                $e->getMessage()
            ));
        }
    }
1186115
public function getFieldDefinition($fieldDefinitionIdentifier)
    {
        $fieldDefinitions = $this->getFieldDefinitions();
        foreach ($fieldDefinitions as $fieldDefinition) {
            if ($fieldDefinition->identifier === $fieldDefinitionIdentifier) {
                return $fieldDefinition;
            }
        }

        return null;
    }
364468
public function getFieldName(SPIValue $value, FieldDefinition $fieldDefinition, $languageCode)
    {
        if (empty($value->destinationContentId)) {
            return '';
        }

        try {
            $contentInfo = $this->handler->loadContentInfo($value->destinationContentId);
            $versionInfo = $this->handler->loadVersionInfo($value->destinationContentId, $contentInfo->currentVersionNo);
        } catch (NotFoundException $e) {
            return '';
        }

        if (isset($versionInfo->names[$languageCode])) {
            return $versionInfo->names[$languageCode];
        }

        return $versionInfo->names[$contentInfo->mainLanguageCode];
    }
687939
public function resolveFieldName($field, array $options = array())
    {
        if(isset($this->mappings[$field])) {
            return $this->mappings[$field];
        }

        throw new \InvalidArgumentException(sprintf('MappedFieldResolver does not support field "%s"', $field));
    }
1111917
public function introspect($field, $value, array $options = [])
    {
        $output = $this->relation($field);
        if ($output) {
            return $output['output'];
        }

        $type = $this->columnType($field);

        $fieldFormatters = $this->getConfig('fieldFormatters');
        if (isset($fieldFormatters[$type])) {
            if (is_callable($fieldFormatters[$type])) {
                return $fieldFormatters[$type]($field, $value, $this->getContext(), $options, $this->getView());
            }

            return $this->{$fieldFormatters[$type]}($field, $value, $options);
        }

        if ($type === 'boolean') {
            return $this->formatBoolean($field, $value, $options);
        }

        if (in_array($type, ['datetime', 'date', 'timestamp'])) {
            return $this->formatDate($field, $value, $options);
        }

        if ($type === 'time') {
            return $this->formatTime($field, $value, $options);
        }

        $value = $this->formatString($field, $value);

        if ($field === $this->getViewVar('displayField')) {
            return $this->formatDisplayField($value, $options);
        }

        return $value;
    }
1097155
public function formatDate($field, $value, array $options)
    {
        if ($value === null) {
            return $this->Html->label(__d('crud', 'N/A'), ['type' => 'info']);
        }

        if (is_int($value) || is_string($value) || $value instanceof DateTime || $value instanceof DateTimeImmutable) {
            return $this->Time->timeAgoInWords($value, $options);
        }

        return $this->Html->label(__d('crud', 'N/A'), ['type' => 'info']);
    }
64486
protected function _render_one_field($field, $options)
    {
        $name = $options['name'] ?? $field;
        $type = $this->getSQLFieldType($options['type'] ?? null, $options);

        return $this->_escape($name).' '.$type;
    }
834353
protected function _parseOptions($fieldName, $options)
    {
        $needsMagicType = false;
        if (empty($options['type'])) {
            $needsMagicType = true;
            $options['type'] = $this->_inputType($fieldName, $options);
        }

        $options = $this->_magicOptions($fieldName, $options, $needsMagicType);

        return $options;
    }
918194
public function getAssetFieldDefinition(): FieldDefinition
    {
        $contentType = $this->contentTypeService->loadContentTypeByIdentifier(
            $this->mappings['content_type_identifier']
        );

        return $contentType->getFieldDefinition(
            $this->mappings['content_field_identifier']
        );
    }
1211588
private function get_field_definition( $type, $options = null ) {

		$definition = PodsForm::field_method( $type, 'schema', $options );

		return $this->do_hook( 'field_definition', $definition, $type, $options );
	}
124130
public function val($field, $options = [])
    {
        $val = parent::val($field, $options);
        if ($val === null) {
            $parts  = explode('.', $field);
            $entity = $this->entity($parts);

            if ($entity instanceof Data) {
                $key = array_pop($parts);
                $val = $entity->get($key);
            }
        }

        return $val;
    }
66559
public function GetField(\Google\Cloud\Firestore\Admin\V1\GetFieldRequest $argument,
      $metadata = [], $options = []) {
        return $this->_simpleRequest('/google.firestore.admin.v1.FirestoreAdmin/GetField',
        $argument,
        ['\Google\Cloud\Firestore\Admin\V1\Field', 'decode'],
        $metadata, $options);
    }
291327
public function updateNonTranslatableField(
        Field $field,
        StorageFieldValue $value,
        $contentId
    ) {
        try {
            return $this->innerGateway->updateNonTranslatableField($field, $value, $contentId);
        } catch (DBALException $e) {
            throw new RuntimeException('Database error', 0, $e);
        } catch (PDOException $e) {
            throw new RuntimeException('Database error', 0, $e);
        }
    }
874430
private function getFullTextFieldValue(Content\Field $field, Type\FieldDefinition $fieldDefinition)
    {
        $fieldType = $this->fieldRegistry->getType($field->type);
        $indexFields = $fieldType->getIndexData($field, $fieldDefinition);

        // find value to be returned (stored in FullTextField)
        $fullTextFieldValue = '';
        foreach ($indexFields as $field) {
            /** @var \eZ\Publish\SPI\Search\Field $field */
            if ($field->type instanceof FieldType\FullTextField) {
                $fullTextFieldValue = $field->value;
                break;
            }
        }

        // some full text fields are stored as an array of strings
        return !is_array($fullTextFieldValue) ? $fullTextFieldValue : implode(' ', $fullTextFieldValue);
    }
207129
protected function getDefaultFieldValue(FieldDescriptorProto $field)
    {
        $type  = $field->getType();
        $value = $field->getDefaultValue();

        if ($value === null) {
            return 'null';
        }

        if ($type === Type::TYPE_ENUM()) {
            $typeName  = $field->getTypeName();
            $refEntity = $this->getEntity($typeName);
            $reference = $refEntity->getNamespacedName();
            $const     = $reference . '::' . $value . '()';

            return $const;
        }

        if ($type === Type::TYPE_BOOL()) {
            $value = filter_var($value, FILTER_VALIDATE_BOOLEAN);
        }

        return var_export($value, true);
    }
1151335
private function getRelation(Content $content, $field, $language)
    {
        $fieldDefinitions = $this->getFieldDefinitionList();
        $fieldNames = array_flip($fieldDefinitions);
        $isRelation = (in_array('ezobjectrelation', $fieldDefinitions) && $field == $fieldNames['ezobjectrelation']);

        if ($isRelation && $field == $fieldNames['ezobjectrelation']) {
            $fieldValue = $content->getFieldValue($fieldNames['ezobjectrelation'], $language);

            if (isset($fieldValue->destinationContentId)) {
                return $fieldValue->destinationContentId;
            }
        }

        return null;
    }
1158027
private function fieldVal($fieldIdent, $val)
    {
        if ($val === null) {
            return null;
        }

        if (is_scalar($val)) {
            return $this->storageVal($val);
        }

        if (isset($val[$fieldIdent])) {
            return $this->storageVal($val[$fieldIdent]);
        } else {
            return null;
        }
    }