Return an array, which is mapping unified namespace class name as key to real edition namespace class name.

@return array

@throws \Exception
489178
public function getClassMap()
    {
        $shopEdition = $this->facts->getEdition();
        $unifiedNamespaceClassMap = null;

        switch ($shopEdition) {
            case \OxidEsales\UnifiedNameSpaceGenerator\Generator::COMMUNITY_EDITION:
                $unifiedNamespaceClassMap =
                    new CommunityEditionUnifiedNamespaceClassMap($this->facts);
                break;
            case \OxidEsales\UnifiedNameSpaceGenerator\Generator::PROFESSIONAL_EDITION:
                $unifiedNamespaceClassMap =
                    new ProfessionalEditionUnifiedNamespaceClassMap($this->facts);
                break;
            case \OxidEsales\UnifiedNameSpaceGenerator\Generator::ENTERPRISE_EDITION:
                $unifiedNamespaceClassMap =
                    new EnterpriseEditionUnifiedNamespaceClassMap($this->facts);
        }

        if (is_null($unifiedNamespaceClassMap)) {
            throw new InvalidEditionException(
                'The OXID eShop edition could not be detected. Be sure to setup your OXID eShop correctly.'
            );
        }

        $editionSpecificUnifiedNamespaceClassMap = $unifiedNamespaceClassMap->getClassMap();

        return $editionSpecificUnifiedNamespaceClassMap;
    }
522488
public function getNamespace()
    {
        if (isset($this->properties[ 'namespace' ])) {
            return $this->properties[ 'namespace' ];
        }

        $dir = $this->getRealPath();
        $dirParts = explode('Widgets' . DIRECTORY_SEPARATOR, $dir);
        $namespace = loader()->getDirNamespace(reset($dirParts)) . 'Widgets\\' . str_replace(['/', DIRECTORY_SEPARATOR],
                '\\', end($dirParts));

        return $namespace;
    }
819871
public function getClassName()
    {
        $classNames = array();
        foreach ($this->_repositories as $repository) {
            $classNames[] = $repository->getClassName();
        }
        return $classNames;
    }
1287089
public function getNamespace(): string
    {
        // Check cache.
        if (null === $this->namespace) {
            $tokens = $this->getTokenStream();
            // Find namespace token
            try {
                $loc = $tokens->scan(0, [T_NAMESPACE]);
            } catch (\OutOfBoundsException $e) {
                return $this->namespace = '';
            }

            // Get the next token (start with namespace)
            if ($loc !== null) {
                $loc = $tokens->next($loc);
            }

            // If the start of the namespace is found,
            // parse it, otherwise save empty namespace.
            $this->namespace = '';
            if ($loc !== null) {
                $this->namespace = $this->parseNamespace($loc);
            }
        }

        return $this->namespace;
    }
63377
public function getNamespaceList()
    {
        if (!isset($this->_namespaceList)) $this->getBasePathList();
        static::$_modulesNs[$this::className()] = $this->_namespaceList;
        return $this->_namespaceList;
    }
454613
public function getAllClassNames(): array
    {
        $auditEntityRepository = $this->getAuditObjectManager()
            ->getRepository('ZF\Doctrine\Audit\Entity\AuditEntity');

        $classNames = [];
        foreach ($this->getJoinEntityConfigCollection() as $className => $config) {
            $classNames[] = $auditEntityRepository->generateClassName($className);
        }

        return $classNames;
    }
888874
private static function getComposerNamespaces()
	{
		static $result = null;
		
		if ( !is_array($result) ) {
			$result = require self::$root . 'vendor/composer/autoload_namespaces.php';
			
			foreach ( $result as $ns => &$paths ) {
				$subpath = trim(str_replace('\\', DIRECTORY_SEPARATOR, $ns), DIRECTORY_SEPARATOR);
				foreach ( $paths as &$path ) {
					$path = rtrim($path, DIRECTORY_SEPARATOR);
					if ( is_dir("$path/$subpath") ) {
						$path = "$path/$subpath";
					}
				}
				unset($path);
			}
			unset($paths);
			
			$psr4 = require self::$root . 'vendor/composer/autoload_psr4.php';
			
			foreach ( $psr4 as $ns => $paths )
			{
				if ( isset($result[$ns]) ) {
					$result[$ns] = array_merge($result[$ns], $paths);
				}
				else {
					$result[$ns] = $paths;
				}
			}
		}
		
		return $result;
	}
260037
public function getExtensionsClassesNames()
    {
        return array_replace([
            Extensions\VinCodeValidatorExtension::class,
            Extensions\GrzCodeValidatorExtension::class,
            Extensions\StsCodeValidatorExtension::class,
            Extensions\PtsCodeValidatorExtension::class,
            Extensions\BodyCodeValidatorExtension::class,
            Extensions\ChassisCodeValidatorExtension::class,
            Extensions\DriverLicenseNumberValidatorExtension::class,
        ], $this->getConfigExtensionsClassesNames());
    }
281711
public function toArray()
    {
        $result = [];

        if (!empty($this->name)) {
            $result['name'] = $this->name;
        }

        if (!empty($this->alias)) {
            $result['alias'] = $this->alias;
        }

        if (!empty($this->using)) {
            $result['using'] = $this->using->toArray();
        }

        if (!empty($this->family)) {
            $result['family'] = $this->family->toArray();
        }

        if (!empty($this->version)) {
            $result['version'] = $this->version->toArray();
        }

        if (!empty($this->type)) {
            $result['type'] = $this->type;
        }

        if (isset($result['version']) && empty($result['version'])) {
            unset($result['version']);
        }

        return $result;
    }
649263
public function handleUninstall(): array
    {
        $result = [];

        $handlers = AbstractOperation::getOperationHandlers($this->composer);

        foreach ($this->projectType->getTypes() as $type) {
            if (isset($handlers[$type])) {
                $class = $handlers[$type];
                /** @var AbstractOperation $handler */
                $handler = new $class($this->package, $this->projectType, $this->composer);
                if ($handler instanceof AvailableOperationInterface) {
                    if (!$handler->isAvailable()) {
                        continue;
                    }
                }
                $result[] = $handler->uninstall();
            }
        }

        return $result;
    }
354502
public function getNamespaceInfo()
    {
        if (empty($this->name)) {
            throw new \RuntimeException('Internal error: SplClassInfo failed to retrieve the reflection object');
        }

        return new SplNamespaceInfo($this->name, $this->getFileName());
    }
582594
public function getNamespace()
	{
	    if (!isset($this->namespace)) {
	        if ($this->isApp()) {
	            $this->namespace = Config::get('app.namespace') ?: '\\' . ucfirst(basename($this->basePath));
	        } else {
	            $name = str_replace(Ioc::app()->basePath, '', $this->basePath);
	            $name = StringHelper::toClassName($name);
	            $this->namespace = Ioc::app()->getNamespace() . '\\' . $name;
	        }
	    }
	    
	    return $this->namespace;
	}
245213
private function getNamespaceVersion()
	{
		if (null !== $this->namespaceVersion) {
			return $this->namespaceVersion;
		}

		$namespaceCacheKey = $this->getNamespaceCacheKey();
		[$found, $version] = $this->doGet($namespaceCacheKey) ?? [false, null];

		if ($found === true) {
			return $this->namespaceVersion = $version;
		}

		return $this->namespaceVersion = 1;
	}
1177934
public function getAllClassNames()
    {
        if (is_array($this->classNames)) {
            return $this->classNames;
        }

        $this->classNames = array_merge(
            $this->reflectionService->getClassNamesByAnnotation(Flow\ValueObject::class),
            $this->reflectionService->getClassNamesByAnnotation(Flow\Entity::class),
            $this->reflectionService->getClassNamesByAnnotation(ORM\Entity::class),
            $this->reflectionService->getClassNamesByAnnotation(ORM\MappedSuperclass::class),
            $this->reflectionService->getClassNamesByAnnotation(ORM\Embeddable::class)
        );
        $this->classNames = array_filter($this->classNames,
            function ($className) {
                return !interface_exists($className, false)
                        && strpos($className, Compiler::ORIGINAL_CLASSNAME_SUFFIX) === false;
            }
        );

        return $this->classNames;
    }
409082
public function getClassMap()
    {
        $communityEditionSourcePath = $this->facts->getCommunityEditionSourcePath();
        $backwardsCompatibilityClassMapFile = $communityEditionSourcePath . DIRECTORY_SEPARATOR .
                                              'Core' . DIRECTORY_SEPARATOR .
                                              'Autoload' . DIRECTORY_SEPARATOR .
                                              'BackwardsCompatibilityClassMap.php';

        if (!is_readable($backwardsCompatibilityClassMapFile)) {
            throw new \OxidEsales\UnifiedNameSpaceGenerator\Exceptions\InvalidBackwardsCompatibilityClassMapException(
                'Backwards compatibility class map file ' . $backwardsCompatibilityClassMapFile .
                ' is not readable or does not exist',
                static::ERROR_CODE_MISSING_BACKWARDS_COMPATIBILITY_CLASS_MAP
            );
        }

        $backwardsCompatibilityClassMap =
            include $backwardsCompatibilityClassMapFile;

        if (!is_array($backwardsCompatibilityClassMap)) {
            throw new \OxidEsales\UnifiedNameSpaceGenerator\Exceptions\InvalidBackwardsCompatibilityClassMapException(
                'Backwards compatibility class map is not an array ',
                static::ERROR_CODE_INVALID_BACKWARDS_COMPATIBILITY_CLASS_MAP
            );
        }

        return array_flip($backwardsCompatibilityClassMap);
    }
614618
public function toArray()
    {
        return [
            'name' => $this->name,
            'class-name' => $this->className,
            'path' => $this->path,
            'is-create' => $this->isCreate,
            'is-virtual' => $this->isVirtual,
            'is-organized' => $this->isOrganized,
            'with-soft-delete' => $this->withSoftDelete,
            'without-timestamps' => $this->withoutTimestamps,
            'resource' => ($this->resource ?: new Resource())->toArray(),
        ];
    }
723974
public function getNamespace()
    {
        if (array_key_exists('namespace', $this->prefs)) {
            return $this->prefs['namespace'];
        }

        if (!$this->getCapability('NAMESPACE')) {
            return self::ERROR_BAD;
        }

        list($code, $response) = $this->execute('NAMESPACE');

        if ($code == self::ERROR_OK && preg_match('/^\* NAMESPACE /', $response)) {
            $response = substr($response, 11);
            $data     = $this->tokenizeResponse($response);
        }

        if (!is_array($data)) {
            return $code;
        }

        $this->prefs['namespace'] = array(
            'personal' => $data[0],
            'other'    => $data[1],
            'shared'   => $data[2],
        );

        return $this->prefs['namespace'];
    }