Get a loader by his alias.

@param $alias

@return mixed
185756
private function getLoader($alias)
    {
        if (!$this->hasLoader($alias)) {
            throw new \RuntimeException(sprintf('Form loader with alias "%s" not found.', $alias));
        }

        return $this->loaders[$alias];
    }
563857
public function getMappingByAlias(string $alias) : Mapping
    {
        foreach ($this->mappings as $mapping) {
            if (0 === strcasecmp($alias, $mapping->getClassAlias())) {
                return $mapping;
            }
        }

        return Mapping::null();
    }
554445
public function getSubqueryByAlias($alias)
    {
        return $this->hasSubqueryAlias($alias) ? $this->getExpression($this->getHash($alias)) : null;
    }
187743
public function findActiveByAlias($alias)
    {
        $query = $this->createValuedQueryBuilder('c')
            ->where('c.alias = :alias')
            ->andWhere('c.active = :active')
            ->setParameters(['alias' => $alias, 'active' => true])
            ->getQuery();

        return $query->useResultCache(true, self::CACHE_TTL)->getSingleResult();
    }
712961
public function resolveClassAlias($alias)
    {
        $alias = static::normalise($alias);

        if (isset($this->classAliases[$alias])) {
            return $this->classAliases[$alias];
        }

        return $alias;
    }
185324
protected function getLoader(): Loader
    {
        $event = LoaderEvent::create(new Loader());
        $this->getEventManager()->dispatch($event);

        return $event->getResultLoader();
    }
1156860
protected function getLoader($type)
    {
        if (!isset($this->loaders[$type])) {
            throw new \InvalidArgumentException("No loader defined for type '${type}'.");
        }

        return $this->loaders[$type];
    }
549467
public function get(string $alias): ManagerInterface
    {
        if (!\array_key_exists($alias, $this->managers)) {
            throw new \InvalidArgumentException(\sprintf('The manager "%s" does not exist', $alias));
        }

        return $this->managers[$alias];
    }
1278445
public function load($alias)
    {
        if (static::$facadeNamespace && strpos($alias, static::$facadeNamespace) === 0) {
            $this->loadFacade($alias);

            return true;
        }

        if (isset($this->aliases[$alias])) {
            return class_alias($this->aliases[$alias], $alias);
        }
    }
68472
private function get_alias_property( $alias )
	{
		if ( array_key_exists( $alias, $this->aliases ) )
			return $this->aliases[$alias];

		return $alias;
	}
1244140
public function load(string $alias): ?bool
    {
        if (\strpos($alias, self::FACADE_NAMESPACE) === 0) {
            return $this->loadFacade($alias);
        }

        if (isset($this->aliases[$alias])) {
            return \class_alias($this->aliases[$alias], $alias);
        }

        return null;
    }
1291661
protected static function getClass($alias)
    {
        if (array_key_exists($alias, self::$filters)) {
            return self::$filters[$alias];
        }

        if (!class_exists($alias)) {
            throw new InvalidArgumentException(
                "Class {$alias} does not exists."
            );
        }
        return $alias;
    }
588535
public function get(string $alias, $throwException = true)
    {
        if (0 !== \strpos($alias, '@')) {
            return $alias;
        }

        $pos = \strpos($alias, '/');
        /** @var string $root */
        $root = $pos === false ? $alias : \substr($alias, 0, $pos);

        if (isset($this->aliases[$root])) {
            return $pos === false ? $this->aliases[$root] : $this->aliases[$root] . \substr($alias, $pos);
        }

        if ($throwException) {
            throw new AliasException("Invalid alias: $alias");
        }

        return null;
    }
5705
protected function mapper($alias = false)
    {
        return Manager::getInstance()->getMapper($alias ? $alias : $this->sMapperAlias);
    }
88757
public function getType($alias)
    {
        if (array_key_exists($alias, $this->types)) {
            return $this->types[$alias];
        }

        return false;
    }
961226
public function toLdapFilter($alias = null)
    {
        if (is_null($alias) && !empty($this->aliases)) {
            $filter = $this->getLdapFilterForAliases();
        } else {
            $filter = $this->getLdapFilter($alias);
        }

        return $filter;
    }
960972
public function getDriver($alias)
    {
        try {
            if ($alias == "Auth") {
                $driver = \Auth::driver();
            } elseif ($alias == "DB") {
                $driver = \DB::connection();
            } elseif ($alias == "Cache") {
                $driver = get_class(\Cache::driver());
                $store = get_class(\Cache::getStore());
                return array($driver, $store);
            } elseif ($alias == "Queue") {
                $driver = \Queue::connection();
            } else {
                return false;
            }

            return get_class($driver);
        } catch (\Exception $e) {
            $this->error("Could not determine driver/connection for $alias.");
            return false;
        }
    }