Getter for $entityClassAlias

@return string $entityClassAlias
5437
public function getEntityClassAlias()
    {
        if ($this->entityClassAlias === null) {
            $entityClass = $this->getEntityClass();
            $this->setEntityClassAlias(strtolower(substr($entityClass, strrpos($entityClass, '\\')+1, 1)));
        }
        return $this->entityClassAlias;
    }
44524
protected function getEntityNameSingular()
    {
        $names = explode('\\', $this->getEntityClassName());
        $name = end($names);
        return lcfirst($name);
    }
420698
public function getEntitiesPath() {
    if (!isset($this->entitiesPath))
      $this->entitiesPath = Code::namespaceToPath($this->entitiesNamespace, $this->project->dir('lib'));
    
    return $this->entitiesPath;
  }
237919
protected function getClassKey($entity)
    {
        $parts = explode('.', $entity);
        $class = array_shift($parts);

        // Ensure the `.ss` suffix gets added to the top level class rather than the key
        if (count($parts) > 1 && reset($parts) === 'ss') {
            $class .= '.ss';
            array_shift($parts);
        }
        $key = implode('.', $parts);
        return array($class, $key);
    }
1117085
private function getEntityName($entityClass)
    {
        if ($this->metadataManager->hasMetadata($entityClass)) {
            return $this->metadataManager->getMetadata($entityClass)->getEntityName();
        }
        if ($this->translatableManager->isTranslation($entityClass)) {
            /** @var \Knp\DoctrineBehaviors\Model\Translatable\Translation $entityClass */
            $translatableClass = $entityClass::getTranslatableEntityClass();

            if ($this->metadataManager->hasMetadata($translatableClass)) {
                return $this->metadataManager->getMetadata($translatableClass)->getEntityName().'_translation';
            }
        }

        return $this->objectNamer->name($entityClass);
    }
302757
public static function modelAlias($className = null)
    {
        if (is_null($className)) {
            $className = get_called_class();
        } elseif (is_object($className)) {
            $className = get_class($className);
        }
        if (!strncmp($className, ':', 1)) {
            // already an alias
            return $className;
        }
        $class = new ReflectionClass($className);
        if ($class->getNamespaceName() === 'app\models') {
            return ':app\\' . $class->getShortName();
        } elseif (($alias = array_search($class->getNamespaceName(), Yii::$app->modelAliases)) !== false) {
            return $alias . '\\' . $class->getShortName();
        }

        return $className;
    }
224086
public function getEntityHydrator($className)
    {
        if (!array_key_exists($className, $this->entityHydrators)) {
            $this->entityHydrators[$className] = new EntityHydrator($className, $this);
        }

        return $this->entityHydrators[$className];
    }
397216
private function getEntityId($entity, $entityClass)
    {
        $ids = $this->em->getClassMetadata($entityClass)->getIdentifierValues($entity);

        return reset($ids);
    }
816601
private function getRouteName($entityClass, $routeType)
    {
        $this->init();

        if (isset($this->routeNames[$entityClass][$routeType])) {
            return $this->routeNames[$entityClass][$routeType];
        }

        $child = $entityClass;

        while ($parent = get_parent_class($child)) {
            if (isset($this->routeNames[$parent][$routeType])) {
                $this->routeNames[$entityClass][$routeType] = $this->routeNames[$parent][$routeType];

                return $this->routeNames[$entityClass][$routeType];
            }

            $child = $parent;
        }

        return null;
    }
1189998
public function findAlias($class){

        $container = Container::open('aliases');

        if( $container->exists($class) ){
            $instance = $container->get($class);
            
            $config['provider'] = $instance;
            if( is_object($instance) ){
                 Container::open('instances')->add($class, $instance);
                 $config['provider'] = 'PlaceHolderClass';
            }
            $result = $this->createAlias($class, $config);
            return $result;
        }

        if( !isset($this->manifestResolver) ){
            $psr4 = require vibius_BASEPATH.'vendor/composer/autoload_psr4.php';
            $manifestResolver = new ManifestResolver($psr4);
            $this->manifestResolver = $manifestResolver;
            $manifestResolver->findManifests();
        }

        $manifestResolver = $this->manifestResolver;

        foreach ($manifestResolver->manifests as $manifestName => $manifestSrc) {
            $manifest = $manifestResolver->getManifest($manifestSrc);

            if( $manifestData = $manifestResolver->verifyManifest($manifest) ){

                foreach ($manifestData['components'] as $component => $componentConfig) {
                    if( $manifestResolver->verifyComponent($componentConfig) ){
                        if( $class === $componentConfig['alias'] ){
                            $componentSrc = explode('../manifest.php',$manifestSrc)[0];
                            $result = $this->createAlias($class, $componentConfig);
                            return $result;
                        }
                    }
                }

            }
            
        }
    }
485110
public function get($entityId)
    {
        $key = $this->getEntityDescriptor()->className();
        $key .= '::'.$entityId;
        $entity = $this->getIdentityMap()->get($key, false);
        if ($entity === false) {
            $entity = $this->load($entityId);
        }
        return $entity;
    }
1234532
private static function getInstance(string $className): string
    {
        $collector = EntityCollector::getCollector();
        if (!isset($collector[$className]['instance'])) {
            return Pool::INSTANCE;
        }

        return $collector[$className]['instance'];
    }
816663
public function getRepository($entityClass)
    {
        $container = $this->getContainer();

        $em = $container->get('doctrine')->getManager();

        /* @var EntityRepository $repository */
        return $em->getRepository($entityClass);
    }
1298058
public function getEntityClassName($entity)
    {
        if (array_key_exists($entity, $this->entityMap)) {
            return $this->entityMap;
        }

        return $this->rootEntityNamespace . $entity;
    }
174337
public static function getClassMetadataFromJoinAlias(string $alias, QueryBuilder $queryBuilder, ManagerRegistry $managerRegistry): ClassMetadata
    {
        @trigger_error(sprintf('The use of "%s::getClassMetadataFromJoinAlias()" is deprecated since 2.4 and will be removed in 3.0. Use "%s::getEntityClassByAlias()" instead.', __CLASS__, QueryBuilderHelper::class), E_USER_DEPRECATED);

        $entityClass = QueryBuilderHelper::getEntityClassByAlias($alias, $queryBuilder, $managerRegistry);

        return $managerRegistry
            ->getManagerForClass($entityClass)
            ->getClassMetadata($entityClass);
    }
647321
public function resolveClassName($alias)
    {
        // Make sure we have string, type-cast Contenttype if needed.
        $alias = (string) $alias;

        if (class_exists($alias)) {
            return $alias;
        }

        if (array_key_exists($alias, $this->aliases)) {
            $class = $this->aliases[$alias];
            if (class_exists($class)) {
                return $class;
            }
        }
        if (array_key_exists($alias, $this->defaultAliases)) {
            $class = $this->defaultAliases[$alias];
            if (class_exists($class)) {
                return $class;
            }
        }
        if (array_key_exists($alias, $this->defaultAliases)) {
            $class = $this->defaultAliases[$alias];
            if (class_exists($class)) {
                return $class;
            }
        }

        return $this->fallbackEntity;
    }
291478
protected function getEntitiesDescriptor()
    {
        $ret = new EntitiesDescriptor();
        $now = time();

        // add RegistrationInfo extension if enabled
        if (!empty($this->regInfo)) {
            $ri = new RegistrationInfo();
            $ri->registrationInstant = $now;
            foreach ($this->regInfo as $riName => $riValues) {
                switch ($riName) {
                    case 'authority':
                        $ri->registrationAuthority = $riValues;
                        break;
                    case 'instant':
                        $ri->registrationInstant = Utils::xsDateTimeToTimestamp($riValues);
                        break;
                    case 'policies':
                        $ri->RegistrationPolicy = $riValues;
                        break;
                }
            }
            $ret->Extensions[] = $ri;
        }

        foreach ($this->sources as $source) {
            $m = $source->getMetadata();
            if ($m === NULL) {
                continue;
            }
            if ($m instanceof EntityDescriptor) {
                $ret->children[] = $m;
            } elseif ($m instanceof EntitiesDescriptor) {
                $ret->children = array_merge($ret->children, self::extractEntityDescriptors($m));
            }
        }

        $ret->children = array_unique($ret->children, SORT_REGULAR);
        $ret->validUntil = $now + $this->validLength;

        return $ret;
    }