9.5/_class_schema_8php_source.html

<?php

namespace ‪TYPO3\CMS\Extbase\Reflection;


/*

 * This file is part of the TYPO3 CMS project.

 *

 * It is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, either version 2

 * of the License, or any later version.

 *

 * For the full copyright and license information, please read the

 * LICENSE.txt file that was distributed with this source code.

 *

 * The TYPO3 project - inspiring people to share!

 */


use Doctrine\Common\Annotations\AnnotationReader;

use ‪TYPO3\CMS\Core\SingletonInterface;

use ‪TYPO3\CMS\Core\Utility\ClassNamingUtility;

use ‪TYPO3\CMS\Core\Utility\GeneralUtility;

use ‪TYPO3\CMS\Core\Utility\StringUtility;

use ‪TYPO3\CMS\Extbase\Annotation\IgnoreValidation;

use ‪TYPO3\CMS\Extbase\Annotation\Inject;

use ‪TYPO3\CMS\Extbase\Annotation\ORM\Cascade;

use ‪TYPO3\CMS\Extbase\Annotation\ORM\Lazy;

use ‪TYPO3\CMS\Extbase\Annotation\ORM\Transient;

use ‪TYPO3\CMS\Extbase\Annotation\Validate;

use ‪TYPO3\CMS\Extbase\DomainObject\AbstractEntity;

use ‪TYPO3\CMS\Extbase\DomainObject\AbstractValueObject;

use ‪TYPO3\CMS\Extbase\Mvc\Controller\ControllerInterface;

use ‪TYPO3\CMS\Extbase\Utility\TypeHandlingUtility;

use ‪TYPO3\CMS\Extbase\Validation\Exception\InvalidTypeHintException;

use ‪TYPO3\CMS\Extbase\Validation\Exception\InvalidValidationConfigurationException;

use ‪TYPO3\CMS\Extbase\Validation\ValidatorResolver;


class ‪ClassSchema

{

    const ‪MODELTYPE_ENTITY = 1;

    const ‪MODELTYPE_VALUEOBJECT = 2;


    protected ‪$className;


    protected ‪$modelType = 0;


    protected ‪$aggregateRoot = false;


    protected ‪$uuidPropertyName;


    protected ‪$properties = [];


    protected ‪$identityProperties = [];


    private ‪$isSingleton;


    private ‪$isController;


    private ‪$methods;


    private ‪$tags;


    private ‪$injectProperties = [];


    private ‪$injectMethods = [];


    public function ‪__construct(‪$className)

    {

        $this->className = ‪$className;


        $reflectionClass = new \ReflectionClass(‪$className);


        $this->‪isSingleton = $reflectionClass->implementsInterface(SingletonInterface::class);

        $this->isController = $reflectionClass->implementsInterface(ControllerInterface::class);


        if ($reflectionClass->isSubclassOf(AbstractEntity::class)) {

            $this->modelType = static::MODELTYPE_ENTITY;


            $possibleRepositoryClassName = ‪ClassNamingUtility::translateModelNameToRepositoryName(‪$className);

            if (class_exists($possibleRepositoryClassName)) {

                $this->‪setAggregateRoot(true);

            }

        }


        if ($reflectionClass->isSubclassOf(AbstractValueObject::class)) {

            $this->modelType = static::MODELTYPE_VALUEOBJECT;

        }


        $docCommentParser = new ‪DocCommentParser(true);

        $docCommentParser->parseDocComment($reflectionClass->getDocComment());

        $this->tags = $docCommentParser->getTagsValues();


        $this->‪reflectProperties($reflectionClass);

        $this->‪reflectMethods($reflectionClass);

    }


    protected function ‪reflectProperties(\ReflectionClass $reflectionClass)

    {

        $annotationReader = new AnnotationReader();


        foreach ($reflectionClass->getProperties() as $reflectionProperty) {

            $propertyName = $reflectionProperty->getName();


            $this->properties[$propertyName] = [

                'default'     => $reflectionProperty->isDefault(),

                'private'     => $reflectionProperty->isPrivate(),

                'protected'   => $reflectionProperty->isProtected(),

                'public'      => $reflectionProperty->isPublic(),

                'static'      => $reflectionProperty->isStatic(),

                'type'        => null, // Extbase

                'elementType' => null, // Extbase

                'annotations' => [],

                'tags'        => [],

                'validators'  => []

            ];


            $docCommentParser = new ‪DocCommentParser(true);

            $docCommentParser->parseDocComment($reflectionProperty->getDocComment());

            foreach ($docCommentParser->getTagsValues() as $tag => $values) {

                $this->properties[$propertyName]['tags'][strtolower($tag)] = $values;

            }


            $this->properties[$propertyName]['annotations']['inject'] = false;

            $this->properties[$propertyName]['annotations']['lazy'] = false;

            $this->properties[$propertyName]['annotations']['transient'] = false;

            $this->properties[$propertyName]['annotations']['type'] = null;

            $this->properties[$propertyName]['annotations']['cascade'] = null;

            $this->properties[$propertyName]['annotations']['dependency'] = null;


            $annotations = $annotationReader->getPropertyAnnotations($reflectionProperty);


            $validateAnnotations = array_filter($annotations, function ($annotation) {

                return $annotation instanceof Validate;

            });


            if (count($validateAnnotations) > 0) {

                $validatorResolver = GeneralUtility::makeInstance(ValidatorResolver::class);


                foreach ($validateAnnotations as $validateAnnotation) {

                    $validatorObjectName = $validatorResolver->resolveValidatorObjectName($validateAnnotation->validator);


                    $this->properties[$propertyName]['validators'][] = [

                        'name' => $validateAnnotation->validator,

                        'options' => $validateAnnotation->options,

                        'className' => $validatorObjectName,

                    ];

                }

            }


            if ($docCommentParser->isTaggedWith('validate')) {

                trigger_error(

                    sprintf(

                        'Property %s::%s is tagged with @validate which is deprecated and will be removed in TYPO3 v10.0.',

                        $reflectionClass->getName(),

                        $reflectionProperty->getName()

                    ),

                    E_USER_DEPRECATED

                );


                $validatorResolver = GeneralUtility::makeInstance(ValidatorResolver::class);


                $validateValues = $docCommentParser->getTagValues('validate');

                foreach ($validateValues as $validateValue) {

                    $validatorConfiguration = $validatorResolver->parseValidatorAnnotation($validateValue);


                    foreach ($validatorConfiguration['validators'] ?? [] as ‪$validator) {

                        $validatorObjectName = $validatorResolver->resolveValidatorObjectName(‪$validator['validatorName']);


                        $this->properties[$propertyName]['validators'][] = [

                            'name' => ‪$validator['validatorName'],

                            'options' => ‪$validator['validatorOptions'],

                            'className' => $validatorObjectName,

                        ];

                    }

                }

            }


            if ($annotationReader->getPropertyAnnotation($reflectionProperty, Lazy::class) instanceof Lazy) {

                $this->properties[$propertyName]['annotations']['lazy'] = true;

            }


            if ($docCommentParser->isTaggedWith('lazy')) {

                $this->properties[$propertyName]['annotations']['lazy'] = true;

                trigger_error(

                    sprintf(

                        'Property %s::%s is tagged with @lazy which is deprecated and will be removed in TYPO3 v10.0.',

                        $reflectionClass->getName(),

                        $reflectionProperty->getName()

                    ),

                    E_USER_DEPRECATED

                );

            }


            if ($annotationReader->getPropertyAnnotation($reflectionProperty, Transient::class) instanceof Transient) {

                $this->properties[$propertyName]['annotations']['transient'] = true;

            }


            if ($docCommentParser->isTaggedWith('transient')) {

                $this->properties[$propertyName]['annotations']['transient'] = true;

                trigger_error(

                    sprintf(

                        'Property %s::%s is tagged with @transient which is deprecated and will be removed in TYPO3 v10.0.',

                        $reflectionClass->getName(),

                        $reflectionProperty->getName()

                    ),

                    E_USER_DEPRECATED

                );

            }


            if ($propertyName !== 'settings'

                && ($annotationReader->getPropertyAnnotation($reflectionProperty, Inject::class) instanceof Inject)

            ) {

                try {

                    $varValue = ltrim($docCommentParser->getTagValues('var')[0], '\\');

                    $this->properties[$propertyName]['annotations']['inject'] = true;

                    $this->properties[$propertyName]['annotations']['type'] = $varValue;

                    $this->properties[$propertyName]['annotations']['dependency'] = $varValue;


                    $this->injectProperties[] = $propertyName;

                } catch (\Exception $e) {

                }

            }


            if ($propertyName !== 'settings' && $docCommentParser->isTaggedWith('inject')) {

                trigger_error(

                    sprintf(

                        'Property %s::%s is tagged with @inject which is deprecated and will be removed in TYPO3 v10.0.',

                        $reflectionClass->getName(),

                        $reflectionProperty->getName()

                    ),

                    E_USER_DEPRECATED

                );

                try {

                    $varValues = $docCommentParser->getTagValues('var');

                    $this->properties[$propertyName]['annotations']['inject'] = true;

                    $this->properties[$propertyName]['annotations']['type'] = ltrim($varValues[0], '\\');

                    $this->properties[$propertyName]['annotations']['dependency'] = ltrim($varValues[0], '\\');


                    if (!$reflectionProperty->isPublic()) {

                        trigger_error(

                            sprintf(

                                'Property %s::%s is not public and tagged with @inject which is deprecated and will stop working in TYPO3 v10.0.',

                                $reflectionClass->getName(),

                                $reflectionProperty->getName()

                            ),

                            E_USER_DEPRECATED

                        );

                    }


                    $this->injectProperties[] = $propertyName;

                } catch (\Exception $e) {

                }

            }


            if ($docCommentParser->isTaggedWith('var') && !$docCommentParser->isTaggedWith('transient')) {

                try {

                    $cascadeAnnotationValues = $docCommentParser->getTagValues('cascade');

                    $this->properties[$propertyName]['annotations']['cascade'] = $cascadeAnnotationValues[0];

                } catch (\Exception $e) {

                }


                if ($this->properties[$propertyName]['annotations']['cascade'] !== null) {

                    trigger_error(

                        sprintf(

                            'Property %s::%s is tagged with @cascade which is deprecated and will be removed in TYPO3 v10.0.',

                            $reflectionClass->getName(),

                            $reflectionProperty->getName()

                        ),

                        E_USER_DEPRECATED

                    );

                }


                if (($annotation = $annotationReader->getPropertyAnnotation($reflectionProperty, Cascade::class)) instanceof Cascade) {

                    $this->properties[$propertyName]['annotations']['cascade'] = $annotation->value;

                }


                try {

                    $type = ‪TypeHandlingUtility::parseType(implode(' ', $docCommentParser->getTagValues('var')));

                } catch (\Exception $e) {

                    $type = [

                        'type' => null,

                        'elementType' => null

                    ];

                }


                $this->properties[$propertyName]['type'] = $type['type'] ? ltrim($type['type'], '\\') : null;

                $this->properties[$propertyName]['elementType'] = $type['elementType'] ? ltrim($type['elementType'], '\\') : null;

            }


            if ($docCommentParser->isTaggedWith('uuid')) {

                $this->‪setUuidPropertyName($propertyName);

            }


            if ($docCommentParser->isTaggedWith('identity')) {

                $this->‪markAsIdentityProperty($propertyName);

            }

        }

    }


    protected function ‪reflectMethods(\ReflectionClass $reflectionClass)

    {

        $annotationReader = new AnnotationReader();


        foreach ($reflectionClass->getMethods() as $reflectionMethod) {

            $methodName = $reflectionMethod->getName();


            $this->methods[$methodName] = [];

            $this->methods[$methodName]['private']      = $reflectionMethod->isPrivate();

            $this->methods[$methodName]['protected']    = $reflectionMethod->isProtected();

            $this->methods[$methodName]['public']       = $reflectionMethod->isPublic();

            $this->methods[$methodName]['static']       = $reflectionMethod->isStatic();

            $this->methods[$methodName]['abstract']     = $reflectionMethod->isAbstract();

            $this->methods[$methodName]['params']       = [];

            $this->methods[$methodName]['tags']         = [];

            $this->methods[$methodName]['annotations']  = [];

            $this->methods[$methodName]['isAction']     = ‪StringUtility::endsWith($methodName, 'Action');


            $docCommentParser = new DocCommentParser(true);

            $docCommentParser->parseDocComment($reflectionMethod->getDocComment());


            $argumentValidators = [];


            $annotations = $annotationReader->getMethodAnnotations($reflectionMethod);


            $validateAnnotations = array_filter($annotations, function ($annotation) {

                return $annotation instanceof Validate;

            });


            if ($this->isController && $this->methods[$methodName]['isAction'] && count($validateAnnotations) > 0) {

                $validatorResolver = GeneralUtility::makeInstance(ValidatorResolver::class);


                foreach ($validateAnnotations as $validateAnnotation) {

                    $validatorName = $validateAnnotation->validator;

                    $validatorObjectName = $validatorResolver->resolveValidatorObjectName($validatorName);


                    $argumentValidators[$validateAnnotation->param][] = [

                        'name' => $validatorName,

                        'options' => $validateAnnotation->options,

                        'className' => $validatorObjectName,

                    ];

                }

            }


            foreach ($docCommentParser->getTagsValues() as $tag => $values) {

                if ($tag === 'cli') {

                    trigger_error(

                        sprintf(

                            'Method %s::%s is tagged with @cli which is deprecated and will be removed in TYPO3 v10.0.',

                            $reflectionClass->getName(),

                            $reflectionMethod->getName()

                        ),

                        E_USER_DEPRECATED

                    );

                }

                if ($tag === 'internal' && $reflectionClass->isSubclassOf(\‪TYPO3\CMS\‪Extbase\Mvc\Controller\CommandController::class)) {

                    trigger_error(

                        sprintf(

                            'Command method %s::%s is tagged with @internal which is deprecated and will be removed in TYPO3 v10.0.',

                            $reflectionClass->getName(),

                            $reflectionMethod->getName()

                        ),

                        E_USER_DEPRECATED

                    );

                }

                if ($tag === 'ignorevalidation') {

                    trigger_error(

                        sprintf(

                            'Method %s::%s is tagged with @ignorevalidation which is deprecated and will be removed in TYPO3 v10.0.',

                            $reflectionClass->getName(),

                            $reflectionMethod->getName()

                        ),

                        E_USER_DEPRECATED

                    );

                }

                if ($tag === 'flushesCaches') {

                    trigger_error(

                        sprintf(

                            'Method %s::%s is tagged with @flushesCaches which is deprecated and will be removed in TYPO3 v10.0.',

                            $reflectionClass->getName(),

                            $reflectionMethod->getName()

                        ),

                        E_USER_DEPRECATED

                    );

                }

                if ($tag === 'validate' && $this->isController && $this->methods[$methodName]['isAction']) {

                    trigger_error(

                        sprintf(

                            'Method %s::%s is tagged with @validate which is deprecated and will be removed in TYPO3 v10.0.',

                            $reflectionClass->getName(),

                            $reflectionMethod->getName()

                        ),

                        E_USER_DEPRECATED

                    );


                    $validatorResolver = GeneralUtility::makeInstance(ValidatorResolver::class);


                    foreach ($values as $validate) {

                        $methodValidatorDefinition = $validatorResolver->parseValidatorAnnotation($validate);


                        foreach ($methodValidatorDefinition['validators'] as ‪$validator) {

                            $validatorObjectName = $validatorResolver->resolveValidatorObjectName(‪$validator['validatorName']);


                            $argumentValidators[$methodValidatorDefinition['argumentName']][] = [

                                'name' => ‪$validator['validatorName'],

                                'options' => ‪$validator['validatorOptions'],

                                'className' => $validatorObjectName,

                            ];

                        }

                    }

                }

                $this->methods[$methodName]['tags'][$tag] = array_map(function ($value) use ($tag) {

                    // not stripping the dollar sign for @validate annotations is just

                    // a quick fix for a regression introduced in 9.0.0.

                    // This exception to the rules will vanish once the resolving of

                    // validators will take place inside this class and not in the

                    // controller during runtime.

                    return $tag === 'validate' ? $value : ltrim($value, '$');

                }, $values);

            }

            unset($methodValidatorDefinition);


            foreach ($annotations as $annotation) {

                if ($annotation instanceof IgnoreValidation) {

                    $this->methods[$methodName]['tags']['ignorevalidation'][] = $annotation->argumentName;

                }

            }


            $this->methods[$methodName]['description'] = $docCommentParser->getDescription();


            foreach ($reflectionMethod->getParameters() as $parameterPosition => $reflectionParameter) {

                /* @var \ReflectionParameter $reflectionParameter */


                $parameterName = $reflectionParameter->getName();


                $this->methods[$methodName]['params'][$parameterName] = [];

                $this->methods[$methodName]['params'][$parameterName]['position'] = $parameterPosition; // compat

                $this->methods[$methodName]['params'][$parameterName]['byReference'] = $reflectionParameter->isPassedByReference(); // compat

                $this->methods[$methodName]['params'][$parameterName]['array'] = $reflectionParameter->isArray(); // compat

                $this->methods[$methodName]['params'][$parameterName]['optional'] = $reflectionParameter->isOptional();

                $this->methods[$methodName]['params'][$parameterName]['allowsNull'] = $reflectionParameter->allowsNull(); // compat

                $this->methods[$methodName]['params'][$parameterName]['class'] = null; // compat

                $this->methods[$methodName]['params'][$parameterName]['type'] = null;

                $this->methods[$methodName]['params'][$parameterName]['nullable'] = $reflectionParameter->allowsNull();

                $this->methods[$methodName]['params'][$parameterName]['default'] = null;

                $this->methods[$methodName]['params'][$parameterName]['hasDefaultValue'] = $reflectionParameter->isDefaultValueAvailable();

                $this->methods[$methodName]['params'][$parameterName]['defaultValue'] = null; // compat

                $this->methods[$methodName]['params'][$parameterName]['dependency'] = null; // Extbase DI

                $this->methods[$methodName]['params'][$parameterName]['validators'] = [];


                if ($reflectionParameter->isDefaultValueAvailable()) {

                    $this->methods[$methodName]['params'][$parameterName]['default'] = $reflectionParameter->getDefaultValue();

                    $this->methods[$methodName]['params'][$parameterName]['defaultValue'] = $reflectionParameter->getDefaultValue(); // compat

                }


                if (($reflectionType = $reflectionParameter->getType()) instanceof \ReflectionNamedType) {

                    $this->methods[$methodName]['params'][$parameterName]['type'] = $reflectionType->getName();

                    $this->methods[$methodName]['params'][$parameterName]['nullable'] = $reflectionType->allowsNull();

                }


                if (($parameterClass = $reflectionParameter->getClass()) instanceof \ReflectionClass) {

                    $this->methods[$methodName]['params'][$parameterName]['class'] = $parameterClass->getName();

                    $this->methods[$methodName]['params'][$parameterName]['type'] = ltrim($parameterClass->getName(), '\\');

                } else {

                    $methodTagsAndValues = $this->methods[$methodName]['tags'];

                    if (isset($methodTagsAndValues['param'][$parameterPosition])) {

                        $explodedParameters = explode(' ', $methodTagsAndValues['param'][$parameterPosition]);

                        if (count($explodedParameters) >= 2) {

                            if (‪TypeHandlingUtility::isSimpleType($explodedParameters[0])) {

                                // ensure that short names of simple types are resolved correctly to the long form

                                // this is important for all kinds of type checks later on

                                $typeInfo = ‪TypeHandlingUtility::parseType($explodedParameters[0]);


                                $this->methods[$methodName]['params'][$parameterName]['type'] = ltrim($typeInfo['type'], '\\');

                            } else {

                                $this->methods[$methodName]['params'][$parameterName]['type'] = ltrim($explodedParameters[0], '\\');

                            }

                        }

                    }

                }


                // Extbase DI

                if ($reflectionParameter->getClass() instanceof \ReflectionClass

                    && ($reflectionMethod->isConstructor() || $this->hasInjectMethodName($reflectionMethod))

                ) {

                    $this->methods[$methodName]['params'][$parameterName]['dependency'] = $reflectionParameter->getClass()->getName();

                }


                // Extbase Validation

                if (isset($argumentValidators[$parameterName])) {

                    if ($this->methods[$methodName]['params'][$parameterName]['type'] === null) {

                        throw new InvalidTypeHintException(

                            'Missing type information for parameter "$' . $parameterName . '" in ' . $this->className . '->' . $methodName . '(): Either use an @param annotation or use a type hint.',

                            1515075192

                        );

                    }


                    $this->methods[$methodName]['params'][$parameterName]['validators'] = $argumentValidators[$parameterName];

                    unset($argumentValidators[$parameterName]);

                }

            }


            // Extbase Validation

            foreach ($argumentValidators as $parameterName => $validators) {

                $validatorNames = array_column($validators, 'name');


                throw new InvalidValidationConfigurationException(

                    'Invalid validate annotation in ' . $this->className . '->' . $methodName . '(): The following validators have been defined for missing param "$' . $parameterName . '": ' . implode(', ', $validatorNames),

                    1515073585

                );

            }


            // Extbase

            $this->methods[$methodName]['injectMethod'] = false;

            if ($this->‪hasInjectMethodName($reflectionMethod)

                && count($this->methods[$methodName]['params']) === 1

                && reset($this->methods[$methodName]['params'])['dependency'] !== null

            ) {

                $this->methods[$methodName]['injectMethod'] = true;

                $this->injectMethods[] = $methodName;

            }

        }

    }


    public function ‪getClassName(): string

    {

        return ‪$this->className;

    }


    public function ‪addProperty($name, $type, $lazy = false, $cascade = '')

    {

        trigger_error(

            'This method will be removed in TYPO3 v10.0, properties will be automatically added on ClassSchema construction.',

            E_USER_DEPRECATED

        );

        $type = ‪TypeHandlingUtility::parseType($type);

        $this->properties[$name] = [

            'type' => $type['type'],

            'elementType' => $type['elementType'],

            'lazy' => $lazy,

            'cascade' => $cascade

        ];

    }


    public function ‪getProperty($propertyName)

    {

        return isset($this->properties[$propertyName]) && is_array($this->properties[$propertyName])

            ? $this->properties[$propertyName]

            : [];

    }


    public function ‪getProperties()

    {

        return ‪$this->properties;

    }


    public function ‪setModelType(‪$modelType)

    {

        trigger_error(

            'This method will be removed in TYPO3 v10.0, modelType will be automatically set on ClassSchema construction.',

            E_USER_DEPRECATED

        );

        if ($modelType < self::MODELTYPE_ENTITY || $modelType > self::MODELTYPE_VALUEOBJECT) {

            throw new \InvalidArgumentException('"' . ‪$modelType . '" is an invalid model type.', 1212519195);

        }

        $this->modelType = ‪$modelType;

    }


    public function ‪getModelType()

    {

        trigger_error(

            'This method will be removed in TYPO3 v10.0.',

            E_USER_DEPRECATED

        );

        return ‪$this->modelType;

    }


    public function ‪setAggregateRoot($isRoot)

    {

        $this->aggregateRoot = $isRoot;

    }


    public function ‪isAggregateRoot(): bool

    {

        return ‪$this->aggregateRoot;

    }


    public function ‪hasProperty($propertyName): bool

    {

        return array_key_exists($propertyName, $this->properties);

    }


    public function ‪setUuidPropertyName($propertyName)

    {

        trigger_error(

            'Tagging properties with @uuid is deprecated and will be removed in TYPO3 v10.0.',

            E_USER_DEPRECATED

        );

        if (!array_key_exists($propertyName, $this->properties)) {

            throw new \InvalidArgumentException('Property "' . $propertyName . '" must be added to the class schema before it can be marked as UUID property.', 1233863842);

        }

        $this->uuidPropertyName = $propertyName;

    }


    public function ‪getUuidPropertyName()

    {

        trigger_error(

            'Tagging properties with @uuid is deprecated and will be removed in TYPO3 v10.0.',

            E_USER_DEPRECATED

        );

        return ‪$this->uuidPropertyName;

    }


    public function ‪markAsIdentityProperty($propertyName)

    {

        trigger_error(

            'Tagging properties with @identity is deprecated and will be removed in TYPO3 v10.0.',

            E_USER_DEPRECATED

        );

        if (!array_key_exists($propertyName, $this->properties)) {

            throw new \InvalidArgumentException('Property "' . $propertyName . '" must be added to the class schema before it can be marked as identity property.', 1233775407);

        }

        if ($this->properties[$propertyName]['annotations']['lazy'] === true) {

            throw new \InvalidArgumentException('Property "' . $propertyName . '" must not be makred for lazy loading to be marked as identity property.', 1239896904);

        }

        $this->identityProperties[$propertyName] = $this->properties[$propertyName]['type'];

    }


    public function ‪getIdentityProperties()

    {

        trigger_error(

            'Tagging properties with @identity is deprecated and will be removed in TYPO3 v10.0.',

            E_USER_DEPRECATED

        );

        return ‪$this->identityProperties;

    }


    public function ‪hasConstructor(): bool

    {

        return isset($this->methods['__construct']);

    }


    public function ‪getMethod(string $name): array

    {

        return $this->methods[$name] ?? [];

    }


    public function ‪getMethods(): array

    {

        return ‪$this->methods;

    }


    protected function ‪hasInjectMethodName(\ReflectionMethod $reflectionMethod): bool

    {

        $methodName = $reflectionMethod->getName();

        if ($methodName === 'injectSettings' || !$reflectionMethod->isPublic()) {

            return false;

        }


        if (

            strpos($reflectionMethod->getName(), 'inject') === 0

        ) {

            return true;

        }


        return false;

    }


    public function ‪isModel(): bool

    {

        return $this->‪isEntity() || $this->‪isValueObject();

    }


    public function ‪isEntity(): bool

    {

        return $this->modelType === static::MODELTYPE_ENTITY;

    }


    public function ‪isValueObject(): bool

    {

        return $this->modelType === static::MODELTYPE_VALUEOBJECT;

    }


    public function ‪isSingleton(): bool

    {

        return ‪$this->isSingleton;

    }


    public function ‪hasMethod(string $methodName): bool

    {

        return isset($this->methods[$methodName]);

    }


    public function ‪getTags(): array

    {

        return ‪$this->tags;

    }


    public function ‪hasInjectProperties(): bool

    {

        return count($this->injectProperties) > 0;

    }


    public function ‪hasInjectMethods(): bool

    {

        return count($this->injectMethods) > 0;

    }


    public function ‪getInjectMethods(): array

    {

        ‪$injectMethods = [];

        foreach ($this->injectMethods as $injectMethodName) {

            ‪$injectMethods[$injectMethodName] = reset($this->methods[$injectMethodName]['params'])['dependency'];

        }


        return ‪$injectMethods;

    }


    public function ‪getInjectProperties(): array

    {

        ‪$injectProperties = [];

        foreach ($this->injectProperties as $injectPropertyName) {

            ‪$injectProperties[$injectPropertyName] = $this->properties[$injectPropertyName]['annotations']['dependency'];

        }


        return ‪$injectProperties;

    }


    public function ‪getConstructorArguments(): array

    {

        if (!$this->‪hasConstructor()) {

            return [];

        }


        return $this->methods['__construct']['params'];

    }

}