ClassAliasMap.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Core;
use Helhum\ClassAliasLoader\Composer\ClassAliasLoader;

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

    protected $aliasToClassNameMapping = array();

    protected $classNameToAliasMapping = array();

    protected $classesCache;

    protected $coreCache;

    protected $classLoader;

    protected $composerClassLoader;

    protected $packages = array();

    public function injectClassesCache(\TYPO3\CMS\Core\Cache\Frontend\StringFrontend $classesCache) {
        $this->classesCache = $classesCache;
    }

    public function injectCoreCache(\TYPO3\CMS\Core\Cache\Frontend\PhpFrontend $coreCache) {
        $this->coreCache = $coreCache;
    }

    public function injectClassLoader(ClassLoader $classLoader) {
        $this->classLoader = $classLoader;
    }

    public function injectComposerClassLoader(ClassAliasLoader $composerClassLoader) {
        $this->composerClassLoader = $composerClassLoader;
    }

    public function setPackages(array $packages) {
        $this->packages = $packages;
        return $this;
    }

    public function buildMappingAndInitializeEarlyInstanceMapping() {
        // Needed for early instance alias mapping
        $aliasToClassNameMapping = array();
        // Final mapping array
        $classNameToAliasMapping = array();
        foreach ($this->packages as $package) {
            if (!$package instanceof \TYPO3\CMS\Core\Package\Package || $package->isProtected()) {
                // Skip non core packages and all protected packages.
                // The latter will be covered by composer class loader.
                continue;
            }
            foreach ($package->getClassAliases() as $aliasClassName => $className) {
                $lowercasedAliasClassName = strtolower($aliasClassName);
                $aliasToClassNameMapping[$lowercasedAliasClassName] = $className;
                $classNameToAliasMapping[$className][$lowercasedAliasClassName] = $lowercasedAliasClassName;
            }
        }
        $this->initializeAndSetAliasesForEarlyInstances($aliasToClassNameMapping);

        return $classNameToAliasMapping;
    }

    public function buildMappingFiles(array $classNameToAliasMapping) {
        foreach ($classNameToAliasMapping as $originalClassName => $aliasClassNames) {
            $originalClassNameCacheEntryIdentifier = str_replace('\\', '_', strtolower($originalClassName));
            // Trigger autoloading for all aliased class names, so a cache entry is created
            $classLoadingInformation = $this->classLoader->buildClassLoadingInformation($originalClassName);
            if (FALSE !== $classLoadingInformation) {
                $classLoadingInformation = implode("\xff", array_merge($classLoadingInformation, $aliasClassNames));
                $this->classesCache->set($originalClassNameCacheEntryIdentifier, $classLoadingInformation);
                foreach ($aliasClassNames as $aliasClassName) {
                    $aliasClassNameCacheEntryIdentifier = str_replace('\\', '_', strtolower($aliasClassName));
                    $this->classesCache->set($aliasClassNameCacheEntryIdentifier, $classLoadingInformation);
                }
            }
        }
    }

    protected function initializeAndSetAliasesForEarlyInstances(array $aliasToClassNameMapping) {
        $classesLoadedPriorToClassLoader = array_intersect($aliasToClassNameMapping, array_merge(get_declared_classes(), get_declared_interfaces()));
        if (empty($classesLoadedPriorToClassLoader)) {
            return;
        }

        foreach ($classesLoadedPriorToClassLoader as $aliasClassName => $originalClassName) {
            $this->setAliasForClassName($aliasClassName, $originalClassName);
        }
    }

    public function setAliasForClassName($aliasClassName, $originalClassName) {
        if (isset($this->aliasToClassNameMapping[$lowercasedAliasClassName = strtolower($aliasClassName)])) {
            return TRUE;
        }
        $this->aliasToClassNameMapping[$lowercasedAliasClassName] = $originalClassName;
        $this->classNameToAliasMapping[strtolower($originalClassName)][$lowercasedAliasClassName] = $aliasClassName;
        return (class_exists($aliasClassName, FALSE) || interface_exists($aliasClassName, FALSE)) ? TRUE : class_alias($originalClassName, $aliasClassName);
    }

    public function getClassNameForAlias($alias) {
        $lookUpClassName = strtolower($alias);
        $className = $this->composerClassLoader->getClassNameForAlias($alias);
        return isset($this->aliasToClassNameMapping[$lookUpClassName]) ? $this->aliasToClassNameMapping[$lookUpClassName] : $className;
    }


    public function getAliasesForClassName($className) {
        $lookUpClassName = strtolower($className);
        return isset($this->classNameToAliasMapping[$lookUpClassName]) ? $this->classNameToAliasMapping[$lookUpClassName] : array($className);
    }
}