ReflectionService.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Extbase\Reflection;

use TYPO3\CMS\Core\Utility\ClassNamingUtility;

class ReflectionService implements \TYPO3\CMS\Core\SingletonInterface {

    protected $objectManager;

    protected $initialized = FALSE;

    protected $dataCache;

    protected $detectClassChanges = FALSE;

    protected $reflectedClassNames = array();

    protected $taggedClasses = array();

    protected $classTagsValues = array();

    protected $methodTagsValues = array();

    protected $methodParameters = array();

    protected $classPropertyNames = array();

    protected $classMethodNames = array();

    protected $propertyTagsValues = array();

    protected $ignoredTags = array('package', 'subpackage', 'license', 'copyright', 'author', 'version', 'const');

    protected $dataCacheNeedsUpdate = FALSE;

    protected $classSchemata = array();

    protected $configurationManager;

    protected $cacheIdentifier;

    protected $methodReflections = array();

    public function setDataCache(\TYPO3\CMS\Core\Cache\Frontend\VariableFrontend $dataCache) {
        $this->dataCache = $dataCache;
    }

    public function initialize() {
        if ($this->initialized) {
            throw new \TYPO3\CMS\Extbase\Reflection\Exception('The Reflection Service can only be initialized once.', 1232044696);
        }
        $frameworkConfiguration = $this->configurationManager->getConfiguration(\TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK);
        $this->cacheIdentifier = 'ReflectionData_' . $frameworkConfiguration['extensionName'];
        $this->loadFromCache();
        $this->initialized = TRUE;
    }

    public function isInitialized() {
        return $this->initialized;
    }

    public function shutdown() {
        if ($this->dataCacheNeedsUpdate) {
            $this->saveToCache();
        }
        $this->initialized = FALSE;
    }

    public function getClassPropertyNames($className) {
        if (!isset($this->reflectedClassNames[$className])) {
            $this->reflectClass($className);
        }
        return isset($this->classPropertyNames[$className]) ? $this->classPropertyNames[$className] : array();
    }

    public function getClassSchema($classNameOrObject) {
        $className = is_object($classNameOrObject) ? get_class($classNameOrObject) : $classNameOrObject;
        if (isset($this->classSchemata[$className])) {
            return $this->classSchemata[$className];
        } else {
            return $this->buildClassSchema($className);
        }
    }

    public function hasMethod($className, $methodName) {
        try {
            if (!array_key_exists($className, $this->classMethodNames) || !array_key_exists($methodName, $this->classMethodNames[$className])) {
                $this->getMethodReflection($className, $methodName);
                $this->classMethodNames[$className][$methodName] = TRUE;
            }
        } catch (\ReflectionException $e) {
            // Method does not exist. Store this information in cache.
            $this->classMethodNames[$className][$methodName] = NULL;
        }
        return isset($this->classMethodNames[$className][$methodName]);
    }

    public function getMethodTagsValues($className, $methodName) {
        if (!isset($this->methodTagsValues[$className][$methodName])) {
            $method = $this->getMethodReflection($className, $methodName);
            $this->methodTagsValues[$className][$methodName] = array();
            foreach ($method->getTagsValues() as $tag => $values) {
                if (array_search($tag, $this->ignoredTags) === FALSE) {
                    $this->methodTagsValues[$className][$methodName][$tag] = $values;
                }
            }
        }
        return $this->methodTagsValues[$className][$methodName];
    }

    public function getMethodParameters($className, $methodName) {
        if (!isset($this->methodParameters[$className][$methodName])) {
            $method = $this->getMethodReflection($className, $methodName);
            $this->methodParameters[$className][$methodName] = array();
            foreach ($method->getParameters() as $parameterPosition => $parameter) {
                $this->methodParameters[$className][$methodName][$parameter->getName()] = $this->convertParameterReflectionToArray($parameter, $parameterPosition, $method);
            }
        }
        return $this->methodParameters[$className][$methodName];
    }

    public function getPropertyTagsValues($className, $propertyName) {
        if (!isset($this->reflectedClassNames[$className])) {
            $this->reflectClass($className);
        }
        if (!isset($this->propertyTagsValues[$className])) {
            return array();
        }
        return isset($this->propertyTagsValues[$className][$propertyName]) ? $this->propertyTagsValues[$className][$propertyName] : array();
    }

    public function getPropertyTagValues($className, $propertyName, $tag) {
        if (!isset($this->reflectedClassNames[$className])) {
            $this->reflectClass($className);
        }
        if (!isset($this->propertyTagsValues[$className][$propertyName])) {
            return array();
        }
        return isset($this->propertyTagsValues[$className][$propertyName][$tag]) ? $this->propertyTagsValues[$className][$propertyName][$tag] : array();
    }

    public function isClassReflected($className) {
        return isset($this->reflectedClassNames[$className]);
    }

    public function isClassTaggedWith($className, $tag) {
        if ($this->initialized === FALSE) {
            return FALSE;
        }
        if (!isset($this->reflectedClassNames[$className])) {
            $this->reflectClass($className);
        }
        if (!isset($this->classTagsValues[$className])) {
            return FALSE;
        }
        return isset($this->classTagsValues[$className][$tag]);
    }

    public function isPropertyTaggedWith($className, $propertyName, $tag) {
        if (!isset($this->reflectedClassNames[$className])) {
            $this->reflectClass($className);
        }
        if (!isset($this->propertyTagsValues[$className])) {
            return FALSE;
        }
        if (!isset($this->propertyTagsValues[$className][$propertyName])) {
            return FALSE;
        }
        return isset($this->propertyTagsValues[$className][$propertyName][$tag]);
    }

    protected function reflectClass($className) {
        $class = new \TYPO3\CMS\Extbase\Reflection\ClassReflection($className);
        $this->reflectedClassNames[$className] = time();
        foreach ($class->getTagsValues() as $tag => $values) {
            if (array_search($tag, $this->ignoredTags) === FALSE) {
                $this->taggedClasses[$tag][] = $className;
                $this->classTagsValues[$className][$tag] = $values;
            }
        }
        foreach ($class->getProperties() as $property) {
            $propertyName = $property->getName();
            $this->classPropertyNames[$className][] = $propertyName;
            foreach ($property->getTagsValues() as $tag => $values) {
                if (array_search($tag, $this->ignoredTags) === FALSE) {
                    $this->propertyTagsValues[$className][$propertyName][$tag] = $values;
                }
            }
        }
        foreach ($class->getMethods() as $method) {
            $methodName = $method->getName();
            foreach ($method->getTagsValues() as $tag => $values) {
                if (array_search($tag, $this->ignoredTags) === FALSE) {
                    $this->methodTagsValues[$className][$methodName][$tag] = $values;
                }
            }
            foreach ($method->getParameters() as $parameterPosition => $parameter) {
                $this->methodParameters[$className][$methodName][$parameter->getName()] = $this->convertParameterReflectionToArray($parameter, $parameterPosition, $method);
            }
        }
        ksort($this->reflectedClassNames);
        $this->dataCacheNeedsUpdate = TRUE;
    }

    protected function buildClassSchema($className) {
        if (!class_exists($className)) {
            throw new \TYPO3\CMS\Extbase\Reflection\Exception\UnknownClassException('The classname "' . $className . '" was not found and thus can not be reflected.', 1278450972);
        }
        $classSchema = $this->objectManager->get('TYPO3\\CMS\\Extbase\\Reflection\\ClassSchema', $className);
        if (is_subclass_of($className, 'TYPO3\\CMS\\Extbase\\DomainObject\\AbstractEntity')) {
            $classSchema->setModelType(\TYPO3\CMS\Extbase\Reflection\ClassSchema::MODELTYPE_ENTITY);
            $possibleRepositoryClassName = ClassNamingUtility::translateModelNameToRepositoryName($className);
            if (class_exists($possibleRepositoryClassName)) {
                $classSchema->setAggregateRoot(TRUE);
            }
        } elseif (is_subclass_of($className, 'TYPO3\\CMS\\Extbase\\DomainObject\\AbstractValueObject')) {
            $classSchema->setModelType(\TYPO3\CMS\Extbase\Reflection\ClassSchema::MODELTYPE_VALUEOBJECT);
        }
        foreach ($this->getClassPropertyNames($className) as $propertyName) {
            if (!$this->isPropertyTaggedWith($className, $propertyName, 'transient') && $this->isPropertyTaggedWith($className, $propertyName, 'var')) {
                $cascadeTagValues = $this->getPropertyTagValues($className, $propertyName, 'cascade');
                $classSchema->addProperty($propertyName, implode(' ', $this->getPropertyTagValues($className, $propertyName, 'var')), $this->isPropertyTaggedWith($className, $propertyName, 'lazy'), $cascadeTagValues[0]);
            }
            if ($this->isPropertyTaggedWith($className, $propertyName, 'uuid')) {
                $classSchema->setUuidPropertyName($propertyName);
            }
            if ($this->isPropertyTaggedWith($className, $propertyName, 'identity')) {
                $classSchema->markAsIdentityProperty($propertyName);
            }
        }
        $this->classSchemata[$className] = $classSchema;
        $this->dataCacheNeedsUpdate = TRUE;
        return $classSchema;
    }

    protected function convertParameterReflectionToArray(\ReflectionParameter $parameter, $parameterPosition, \ReflectionMethod $method = NULL) {
        $parameterInformation = array(
            'position' => $parameterPosition,
            'byReference' => $parameter->isPassedByReference(),
            'array' => $parameter->isArray(),
            'optional' => $parameter->isOptional(),
            'allowsNull' => $parameter->allowsNull()
        );
        $parameterClass = $parameter->getClass();
        $parameterInformation['class'] = $parameterClass !== NULL ? $parameterClass->getName() : NULL;
        if ($parameter->isDefaultValueAvailable()) {
            $parameterInformation['defaultValue'] = $parameter->getDefaultValue();
        }
        if ($parameterClass !== NULL) {
            $parameterInformation['type'] = $parameterClass->getName();
        } elseif ($method !== NULL) {
            $methodTagsAndValues = $this->getMethodTagsValues($method->getDeclaringClass()->getName(), $method->getName());
            if (isset($methodTagsAndValues['param']) && isset($methodTagsAndValues['param'][$parameterPosition])) {
                $explodedParameters = explode(' ', $methodTagsAndValues['param'][$parameterPosition]);
                if (count($explodedParameters) >= 2) {
                    $parameterInformation['type'] = $explodedParameters[0];
                }
            }
        }
        if (isset($parameterInformation['type']) && $parameterInformation['type'][0] === '\\') {
            $parameterInformation['type'] = substr($parameterInformation['type'], 1);
        }
        return $parameterInformation;
    }

    protected function getMethodReflection($className, $methodName) {
        $this->dataCacheNeedsUpdate = TRUE;
        if (!isset($this->methodReflections[$className][$methodName])) {
            $this->methodReflections[$className][$methodName] = new \TYPO3\CMS\Extbase\Reflection\MethodReflection($className, $methodName);
        }
        return $this->methodReflections[$className][$methodName];
    }

    protected function loadFromCache() {
        $data = $this->dataCache->get($this->cacheIdentifier);
        if ($data !== FALSE) {
            foreach ($data as $propertyName => $propertyValue) {
                $this->{$propertyName} = $propertyValue;
            }
        }
    }

    protected function saveToCache() {
        if (!is_object($this->dataCache)) {
            throw new \TYPO3\CMS\Extbase\Reflection\Exception('A cache must be injected before initializing the Reflection Service.', 1232044697);
        }
        $data = array();
        $propertyNames = array(
            'reflectedClassNames',
            'classPropertyNames',
            'classMethodNames',
            'classTagsValues',
            'methodTagsValues',
            'methodParameters',
            'propertyTagsValues',
            'taggedClasses',
            'classSchemata'
        );
        foreach ($propertyNames as $propertyName) {
            $data[$propertyName] = $this->{$propertyName};
        }
        $this->dataCache->set($this->cacheIdentifier, $data);
        $this->dataCacheNeedsUpdate = FALSE;
    }
}