Gets the hydrator class name.

@param string $fqcn

@return string
779253
public function getHydratorClassName($fqcn)
    {
        $config = new Configuration($fqcn);
        $config->setAutoGenerateProxies($this->generateProxies);
        $config->setGeneratedClassesTargetDir($this->cacheDir);

        return $config->createFactory()->getHydratorClass();
    }
265859
public function findOneByBundleFQCN($fqcn)
    {
        $split = explode('\\', $fqcn);
        $dql = '
            SELECT p FROM Claroline\CoreBundle\Entity\Plugin p
            WHERE p.vendorName = :vendor
            AND p.bundleName = :bundle
        ';
        $query = $this->_em->createQuery($dql);
        $query->setParameter('vendor', $split[0]);
        $query->setParameter('bundle', $split[1]);
        $results = $query->getResult();

        return count($results) !== 0 ? $results[0] : null;
    }
813327
private function getHydrator($class): \Closure
    {
        if (isset($this->hydrators[$class])) {
            return $this->hydrators[$class];
        }

        return $this->hydrators[$class] = \Closure::bind(function ($object, array $properties) {
            foreach ($properties as $property => $value) {
                $object->$property = $value;
            }
        }, \null, $class);
    }
408568
public function getInterfacesNamespaceForEntity(
        string $entityFqn
    ): string {
        $interfacesNamespace = $this->getProjectNamespaceRootFromEntityFqn($entityFqn)
                               . AbstractGenerator::ENTITY_RELATIONS_NAMESPACE
                               . '\\' . $this->getEntitySubNamespace($entityFqn)
                               . '\\Interfaces';

        return $this->tidy($interfacesNamespace);
    }
331943
public function get(string $fqcn): ProxyInterface
    {
        $mock = $this->mockingStrategy->build($fqcn);
        $mockFQCN = \get_class($this->mockingStrategy->get($mock));
        $mockClass = new \ReflectionClass($mockFQCN);

        $proxyCode = ClassTemplate::generate($mockClass);
        $proxyFQCN = eval($proxyCode);

        return $this->getInstance($proxyFQCN)
            ->__moka_setMock($mock)
            ->__moka_setMockingStrategy($this->mockingStrategy);
    }
787386
public function findOneByBundleFQCN($fqcn)
    {
        $split = explode('\\', $fqcn);

        return $this->_em
            ->createQuery('
                SELECT p FROM Claroline\CoreBundle\Entity\Plugin p
                WHERE p.vendorName = :vendor
                AND p.bundleName = :bundle
            ')
            ->setParameter('vendor', $split[0])
            ->setParameter('bundle', $split[1])
            ->getOneOrNullResult();
    }
810770
private static Class getClass(final String fqcn) {

		try {

			return Class.forName(fqcn);

		} catch (Throwable t) {

		}

		return null;
	}
636867
public static function fqcnToBlockPrefix(string $fqcn): ?string
    {
        // Non-greedy ("+?") to match "type" suffix, if present
        if (preg_match('~([^\\\\]+?)(type)?$~i', $fqcn, $matches)) {
            return mb_strtolower(preg_replace(['/([A-Z]+)([A-Z][a-z])/', '/([a-z\d])([A-Z])/'], ['\\1_\\2', '\\1_\\2'], $matches[1]));
        }

        return null;
    }
925116
public function getFileAnalyzerForClassLike($fq_class_name)
    {
        $fq_class_name_lc = strtolower($fq_class_name);

        $file_path = $this->codebase->scanner->getClassLikeFilePath($fq_class_name_lc);

        $file_analyzer = new FileAnalyzer(
            $this,
            $file_path,
            $this->config->shortenFileName($file_path)
        );

        return $file_analyzer;
    }
312455
public static function getSingularForFqn(string $entityFqn): string
    {
        $shortName = self::getShortNameForFqn($entityFqn);
        $singular  = self::singularize($shortName);

        return lcfirst($singular);
    }
987487
private final static function loadClass($fqcn)
    {
        $reflectionClass = new ReflectionClass($fqcn);
        $constants       = $reflectionClass->getConstants();

        foreach ($constants as $name => $value) {
            $instance = new $fqcn($fqcn, $name, $value);

            /* @var $instance Enum */
            if (is_callable([$instance, '__initEnum'])) {
                $instance->__initEnum();
            }

            $instanceConstructorName = '__' . $name;
            if (is_callable([$instance, $instanceConstructorName])) {
                $instance->$instanceConstructorName();
            }

            if (!isset(self::$instances[$fqcn])) {
                self::$instances[$fqcn] = [];
            }

            self::$instances[$fqcn][$name] = $instance;
        }
    }
300069
protected function getRelativePath($fqcn)
    {
        if (strpos($fqcn, $this->getRootNamespace().'\\') === 0) {
            $relative = substr($fqcn, strlen($this->getRootNamespace()) + 1);
        }
        else {
            $relative = $fqcn;
        }

        return str_replace('\\', '/', $relative);
    }
91047
public static function hydrateCollection(array $queues)
    {
        $hydrated = [];

        foreach ($queues as $queue) {
            $hydrated[] = self::hydrate($queue);
        }

        return $hydrated;
    }
1038966
public function getQueueAliasByQueueName(string $queueName): string
    {
        return is_array($this->queues)
            ? ((array_flip($this->queues)[$queueName]) ?? $queueName)
            : $queueName;
    }
550778
public function getFQCNFromTemplateName($templateName)
    {
        $classname = $this->compiledNamespace."\\".$templateName;
        $classname = str_replace('/', '\\', $classname);
        $classname .= "Jig";

        return $classname;
    }
1058444
public function getFQN()
    {
        if (empty($this->namespaceId) || empty($this->name))
            return "";

        return sprintf("%s:%s", $this->namespaceId, $this->name);
    }
420379
public function guessEntityEntry(string $entityFqcn)
    {
        $matchingEntityConfigs = \array_filter(
            $this->easyAdminConfig['entities'],
            function ($entityConfig) use ($entityFqcn) {
                return $entityFqcn === $entityConfig['class'];
            }
        );

        if (empty($matchingEntityConfigs)) {
            throw new \RuntimeException(
                \sprintf('No entity defined in EasyAdmin configuration matches %s FQCN.', $entityFqcn)
            );
        }

        if (1 < \count($matchingEntityConfigs)) {
            throw new \RuntimeException(
                \sprintf('More than 1 entity defined in EasyAdmin configuration matches %s FQCN.', $entityFqcn)
            );
        }

        return (string) \key($matchingEntityConfigs);
    }