Registers an eZ Publish field type.
Field types are being registered as a closure so that they will be lazy loaded.

@param string $fieldTypeServiceId The field type service Id
@param string $fieldTypeAlias The field type alias (e.g. "ezstring")
327618
public function registerFieldType($fieldTypeServiceId, $fieldTypeAlias)
    {
        $container = $this->container;
        $this->fieldTypes[$fieldTypeAlias] = function () use ($container, $fieldTypeServiceId) {
            return $container->get($fieldTypeServiceId);
        };
    }
340929
public function parseValidatorConfiguration($fieldTypeIdentifier, $configurationHash)
    {
        if ($this->fieldTypeProcessorRegistry->hasProcessor($fieldTypeIdentifier)) {
            $fieldTypeProcessor = $this->fieldTypeProcessorRegistry->getProcessor($fieldTypeIdentifier);
            $configurationHash = $fieldTypeProcessor->preProcessValidatorConfigurationHash($configurationHash);
        }

        $fieldType = $this->fieldTypeService->getFieldType($fieldTypeIdentifier);

        return $fieldType->validatorConfigurationFromHash($configurationHash);
    }
90441
public function hasFieldType(ContentType $contentType, string $fieldTypeIdentifier): bool
    {
        foreach ($contentType->getFieldDefinitions() as $fieldDefinition) {
            if ($fieldDefinition->fieldTypeIdentifier === $fieldTypeIdentifier) {
                return true;
            }
        }

        return false;
    }
258432
public function registerEncoder(string $type, IEncoder $encoder): void
    {
        $normalizedType = self::normalizeType($type);
        $this->encodersByType[$normalizedType] = $encoder;
    }
769596
public function registerType($name, $handler, $aliases = array())
    {
        trigger_error("Types are deprecated, use JsonTypes through registerJsonType.", E_USER_DEPRECATED);
        $this->registerJsonType($name, new OldTypeWrapper($handler), $aliases);
    }
414889
protected function serviceRegistrar(string $type): void
	{
		foreach($this->config->get('application.services.' . $type) as $service)
		{
			(new $service($this, $this->container, $this->config))->register();
		}
	}
85732
static function register( $dataTypeString, $className )
    {
        $types =& $GLOBALS["eZDataTypes"];
        if ( !is_array( $types ) )
            $types = array();
        $types[$dataTypeString] = $className;
    }
1188446
protected void registerColumnType(String columnType, int jdbcType) {
        columnTypeMatchers.add(new ColumnTypeMatcher(columnType));
        jdbcTypes.put(columnType, jdbcType);
    }
846327
public function registerEntityAliases() {

		$factory = Yii::$app->factory->getContainer();

		$factory->set( 'chatService', 'cmsgears\community\common\services\entities\ChatService' );

		$factory->set( 'groupService', 'cmsgears\community\common\services\entities\GroupService' );
	}
867960
private static Class registerTypeMapping(Class clazz) throws PageException {
	PageContext pc = ThreadLocalPageContext.get();
	WSServer server = ((ConfigImpl) ThreadLocalPageContext.getConfig(pc)).getWSHandler().getWSServer(pc);
	return registerTypeMapping(server, clazz);
    }
951887
public function registerTemplateType(array $templateTypeData)
    {
        $templateType = $this->normalizer->denormalize(
            array('id' => $templateTypeData['id'], 'name' => $templateTypeData['name']),
            $this->entityCollection->getEntityClass()
        );
        foreach ($templateTypeData['zones'] as $zoneTypeId) {
            $templateType->getZoneTypes()->set(
                $zoneTypeId,
                $this->zoneTypeLoader->retrieve($zoneTypeId)
            );
        }

        $this->entityCollection->set($templateType->getId(), $templateType);
    }
442179
public static function registerSerializerFactory($factory, string ...$contentTypes) {
    foreach ($contentTypes as $contentType) {
      self::getSerializerFactories()[$contentType] = $factory;
    }
  }
611360
public function getFieldTypeService()
    {
        if ($this->fieldTypeService !== null) {
            return $this->fieldTypeService;
        }

        $this->fieldTypeService = new FieldTypeService($this->getFieldTypeRegistry());

        return $this->fieldTypeService;
    }
12671
protected function registerMediaTypeParser(array $mediaTypes, callable $parser)
    {
        if ($parser instanceof \Closure) {
            $parser = $parser->bindTo($this);
        }

        foreach ($mediaTypes as $mediaType) {
            $this->bodyParsers[$mediaType] = $parser;
        }
    }
560590
public function setFieldDefinitionsList(ContentType $contentType)
    {
        foreach ($contentType->fieldDefinitions as $fieldDef) {
            $this->fieldDefIdentifiers[$fieldDef->identifier] = $fieldDef->fieldTypeIdentifier;
        }
    }
231112
private function initFieldType($type)
    {
        if (isset($this->fieldTypes[$type])) {
            return;
        }

        $typeInstance = false;
        foreach ($this->extensions as $extension) {
            if ($extension->hasFieldType($type)) {
                $typeInstance = $extension->getFieldType($type);
                break;
            }
        }

        if (!$typeInstance) {
            return;
        }

        $this->fieldTypes[$type] = $typeInstance;

        $ext = [];
        foreach ($this->extensions as $extension) {
            if ($extension->hasFieldTypeExtensions($type)) {
                $fieldExtensions = $extension->getFieldTypeExtensions($type);
                foreach ($fieldExtensions as $fieldExtension) {
                    $ext[] = $fieldExtension;
                }
            }
        }

        $this->fieldExtensions[$type] = $ext;
    }
413613
private function getRenderFieldBlockName($fieldTypeIdentifier, $type)
    {
        $suffix = $type === self::EDIT ? self::FIELD_EDIT_SUFFIX : self::FIELD_VIEW_SUFFIX;

        return $fieldTypeIdentifier . $suffix;
    }