{@inheritdoc}
@return string
@throws \OutOfBoundsException
@throws \Hostnet\Component\AccessorGenerator\Reflection\Exception\ClassDefinitionNotFoundException
978180
public function getClass(): string
    {
        if ($this->property->getClass() !== null) {
            return $this->property->getClass()->getName();
        }

        return '';
    }
361245
public function subclass(): SubClassMappingDefiner
    {
        $this->verifyDefinedClass();

        return new SubClassMappingDefiner(
            $this->orm,
            $this,
            function (callable $mappingLoader, MapperDefinition $subClassDefinition) {
                $subClassDefinition->verifyDefinedClass();
                $subClassName = $subClassDefinition->class->getClassName();

                if (!is_a($subClassName, $this->class->getClassName(), true)) {
                    throw IncompleteMapperDefinitionException::format(
                        'Invalid subclass mapper definition for: defined type must be a subclass of %s, %s given',
                        $this->class->getClassName(),
                        $subClassName
                    );
                }

                $this->subClassMappingFactories[$subClassName] = $mappingLoader;
            }
        );
    }
626382
public function resolveClassname()
    {
        $resolver = $this->smd->getNameResolver();
        if ( $resolver && is_callable($resolver) ) {
            return call_user_func_array($resolver, [$this]);
        }
        return $this->getDottedClassname();
    }
158282
public function toRouteDefinition()
    {
        $routes = [];

        foreach ($this->paths as $path) {
            $routes[] = sprintf(
                $this->getTemplate(), 'Resource: '.$this->name.'@'.$path->method,
                $this->implodeArray($this->getMiddleware($path)),
                var_export($path->path, true), $this->implodeArray($path->where),
                var_export($path->domain, true), var_export($this->name, true),
                var_export($this->reflection->name, true), $this->implodeArray([$path->method]),
                $this->implodeArray($this->getNames($path))
            );
        }

        return implode(PHP_EOL.PHP_EOL, $routes);
    }
1036028
public function getAdapterInstance()
    {
        if ($this->adapter instanceof Encrypt\EncryptionAlgorithmInterface) {
            return $this->adapter;
        }

        $adapter = $this->adapter;
        $options = $this->getOptions();
        if (! class_exists($adapter)) {
            $adapter = __CLASS__ . '\\' . ucfirst($adapter);
            if (! class_exists($adapter)) {
                throw new Exception\RuntimeException(sprintf(
                    '%s unable to load adapter; class "%s" not found',
                    __METHOD__,
                    $this->adapter
                ));
            }
        }

        $this->adapter = new $adapter($options);
        if (! $this->adapter instanceof Encrypt\EncryptionAlgorithmInterface) {
            throw new Exception\InvalidArgumentException(sprintf(
                'Encryption adapter "%s" does not implement %s\\EncryptionAlgorithmInterface',
                $adapter,
                __CLASS__
            ));
        }
        return $this->adapter;
    }
1172384
private function getClassDeclaration()
    {
        return new Format(
            sprintf(
                '%sclass %s%s%s',
                $this->isAbstract ? 'abstract ' : '',
                $this->class,
                $this->getImplementOrExtendsDeclaration('extends', $this->extends),
                $this->getImplementOrExtendsDeclaration('implements', $this->implements)
            )
        );
    }
250052
public static function getIgnoredClassesRegex(): string
    {
        if (self::$ignoredClassesRegex !== '') {
            return self::$ignoredClassesRegex;
        }

        $ignoredClassesConfiguration = self::$ignoredClassesFallback;
        $ignoredClasses = [];

        if (self::$objectManager instanceof ObjectManagerInterface) {
            $configurationManager = self::$objectManager->get(ConfigurationManager::class);
            if ($configurationManager instanceof ConfigurationManager) {
                $ignoredClassesFromSettings = $configurationManager->getConfiguration('Settings', 'Neos.Flow.error.debugger.ignoredClasses');
                if (is_array($ignoredClassesFromSettings)) {
                    $ignoredClassesConfiguration = Arrays::arrayMergeRecursiveOverrule($ignoredClassesConfiguration, $ignoredClassesFromSettings);
                }
            }
        }

        foreach ($ignoredClassesConfiguration as $classNamePattern => $active) {
            if ($active === true) {
                $ignoredClasses[] = $classNamePattern;
            }
        }

        self::$ignoredClassesRegex = sprintf('/^%s$/xs', implode('$|^', $ignoredClasses));

        return self::$ignoredClassesRegex;
    }
1332998
public function getNext()
	{
		if (! $this->valid()) {
			throw new \OutOfBoundsException('End of iterator reached.');
		}

		$value = $this->get($this->key());

		$this->next();

		return $value;
	}
885938
public function getAreaLayoutColumnOffsetEditClass()
    {
        /*
         * @var ThemeGridLayout $this->arLayout
         */
        $gf = $this->arLayout->getThemeGridFrameworkObject();
        if (is_object($gf)) {
            $class = $gf->getPageThemeGridFrameworkColumnAdditionalClasses();
            if ($class) {
                $class .= ' ';
            }

            $class .= $gf->getPageThemeGridFrameworkColumnClassForSpan($this->arLayoutColumnOffset);

            return $class;
        }
    }
68355
protected function getWriter()
    {
        if (!isset($this->writers[$this->type])) {
            throw new OutOfBoundsException($this->translate(
                'Writer "{type}" is not available.',
                ['type' => $this->type]
            ));
        }

        return $this->getPrototype($this->writers[$this->type], ['umi\config\io\writer\IWriter'])->createSingleInstance();
    }
522818
public function render()
    {
        $namespace = $this->namespace;
        $proxyClassName = $this->originalClassName;
        $originalClassName = $this->originalClassName . Compiler::ORIGINAL_CLASSNAME_SUFFIX;
        $classModifier = '';
        if ($this->reflectionService->isClassAbstract($this->fullOriginalClassName)) {
            $classModifier = 'abstract ';
        } elseif ($this->reflectionService->isClassFinal($this->fullOriginalClassName)) {
            $classModifier = 'final ';
        }

        $constantsCode = $this->renderConstantsCode();
        $propertiesCode = $this->renderPropertiesCode();
        $traitsCode = $this->renderTraitsCode();

        $methodsCode = isset($this->constructor) ? $this->constructor->render() : '';
        foreach ($this->methods as $proxyMethod) {
            $methodsCode .= $proxyMethod->render();
        }

        if ($methodsCode . $constantsCode === '') {
            return '';
        }
        $classCode = ($namespace !== '' ? 'namespace ' . $namespace . ";\n\n" : '') .
            "use Doctrine\\ORM\\Mapping as ORM;\n" .
            "use Neos\\Flow\\Annotations as Flow;\n" .
            "\n" .
            $this->buildClassDocumentation() .
            $classModifier . 'class ' . $proxyClassName . ' extends ' . $originalClassName . ' implements ' . implode(', ', array_unique($this->interfaces)) . " {\n\n" .
            $traitsCode .
            $constantsCode .
            $propertiesCode .
            $methodsCode .
            '}';
        return $classCode;
    }
532703
public function getHydratorClass() : string
    {
        $inflector         = $this->configuration->getClassNameInflector();
        $realClassName     = $inflector->getUserClassName($this->configuration->getHydratedClassName());
        $hydratorClassName = $inflector->getGeneratedClassName($realClassName, ['factory' => static::class]);

        if (! class_exists($hydratorClassName) && $this->configuration->doesAutoGenerateProxies()) {
            $generator     = $this->configuration->getHydratorGenerator();
            $originalClass = new ReflectionClass($realClassName);
            $generatedAst  = $generator->generate($originalClass);
            $traverser     = new NodeTraverser();

            $traverser->addVisitor(new ClassRenamerVisitor($originalClass, $hydratorClassName));

            $this->configuration->getGeneratorStrategy()->generate($traverser->traverse($generatedAst));
            $this->configuration->getGeneratedClassAutoloader()->__invoke($hydratorClassName);
        }

        return $hydratorClassName;
    }
1260171
public function getDescription()
    {
        $reflectionClass = new \ReflectionClass($this);
        $lines = explode(chr(10), $reflectionClass->getDocComment());
        foreach ($lines as $line) {
            $line = trim($line);
            if ($line === '' || $line === '/**' || $line === '*' || $line === '*/' || strpos($line, '* @') !== false) {
                continue;
            }
            return preg_replace('/\s*\\/?[\\\\*]*\s?(.*)$/', '$1', $line);
        }
    }
1096849
public function current(): MessageInterface
    {
        $current = parent::current();
        if (!\is_int($current)) {
            throw new Exception\OutOfBoundsException(\sprintf(
                'The current value "%s" isn\'t an integer and doesn\'t represent a message;'
                . ' try to cycle this "%s" with a native php function like foreach or with the method getArrayCopy(),'
                . ' or check it by calling the methods valid().',
                \is_object($current) ? \get_class($current) : \gettype($current),
                static::class
            ));
        }

        return new Message($this->resource, $current);
    }
486088
protected function getReader()
    {
        if (!isset($this->readers[$this->type])) {
            throw new OutOfBoundsException($this->translate(
                'Reader "{type}" is not available.',
                ['type' => $this->type]
            ));
        }

        return $this->getPrototype($this->readers[$this->type], ['umi\config\io\reader\IReader'])->createSingleInstance();
    }
158347
public function getMetadataFor($className)
    {
        if (!$this->isService($className)) {
            throw Exception::classIsNotMappedService($className);
        }

        if (!isset($this->loadedMetadata[$className])) {
            $this->loadMetadata($className);
        }

        if ($this->cache) {
            $cacheId = $this->cachePrefix . $className . $this->cacheSuffix;

            if (($cached = $this->cache->fetch($cacheId)) !== false) {
                $this->loadedMetadata[$className] = $cached;
            } else {
                $this->loadMetadata($className);
                $this->cache->save($cacheId, $this->loadedMetadata[$className], null);
            }
        } else {
            $this->loadMetadata($className);
        }

        return $this->loadedMetadata[$className];
    }
338687
private function getEntityClassName($entityName)
    {
        if (!isset($this->entityClassMap[ $entityName ])) {
            $className = $entityName;
            if (!class_exists($className)) {
                $className = $this->defaultNamespace . $entityName;
                if (!class_exists($className)) {
                    //Cache that the class does not exist
                    $className = false;
                }
            }
            $this->entityClassMap[ $entityName ] = $className;
        }

        if ($this->entityClassMap[ $entityName ] === false) {
            throw new \OutOfBoundsException("Unknown entity {$entityName}");
        }

        return $this->entityClassMap[ $entityName ];
    }