Get model's class name by it's alias defined in module's config.
@param string $alias
@return string class name
@throws Exception if the alias not found.
331392
public function getModelClassname($alias)
    {
        if (empty($this->_models[$alias])) {
            throw new Exception("Shared model '{$alias}' not found in configuration of module " . static::className());
        }
        return $this->_models[$alias];
    }
510964
public function getFieldByAlias($alias)
    {
        foreach ($this->_fields as $column => $fields)
        {
            foreach ($fields as $field)
            {
                if ($field->getAlias() === $alias)
                {
                    return $field;
                }
            }
        }
        return null;
    }
38008
protected function
	GetConnectionConfig($Alias) {
	/*//
	@return Nether\Database\Connection
	fetch the specified configuration. if none is found then it will throw an
	exception instead.
	//*/

		$Config = Nether\Option::Get('nether-database-connections');

		if(!array_key_exists($Alias,$Config))
		throw new Nether\Database\Error\InvalidConfig($Alias);

		if($Config[$Alias] instanceof Nether\Database\Connection)
		return $Config[$Alias];

		return new Nether\Database\Connection($Config[$Alias]);
	}
913460
public function getAliasNamespace($alias)
    {
        foreach (array_keys($this->getManagers()) as $name) {
            try {
                return $this->getManager($name)->getConfiguration()->getEntityNamespace($alias);
            } catch (ORMException $e) {
            }
        }

        throw ORMException::unknownEntityNamespace($alias);
    }
1201700
protected function getIdentifier( $alias )
    {
        $aliasParts = explode( '.', $alias );
        $identifiers = array();
        // If the alias consists of one part, then we just look it up in the
        // array. If we find it, we use it, otherwise we return the name as-is
        // and assume it's just a column name. The alias target can be a fully
        // qualified name (table.column).
        if ( count( $aliasParts ) == 1 )
        {
            if ( $this->aliases !== null &&
                array_key_exists( $alias, $this->aliases ) )
            {
                $alias = $this->aliases[$alias];
            }
            return $alias;
        }
        // If the passed name consist of two parts, we need to check all parts
        // of the passed-in name for aliases, because an alias can be made for
        // both a table name and a column name. For each element we try to find
        // whether we have an alias mapping. Unlike the above case, the alias
        // target can in this case *not* consist of a fully qualified name as
        // this would introduce another part of the name (with two dots).
        for ( $i = 0; $i < count( $aliasParts ); $i++ )
        {
            if ( $this->aliases !== null &&
                array_key_exists( $aliasParts[$i], $this->aliases ) )
            {
                // We only use the found alias if the alias target is not a fully
                // qualified name (table.column).
                $tmpAlias = $this->aliases[$aliasParts[$i]];
                if ( count( explode( '.', $tmpAlias ) ) === 1 )
                {
                    $aliasParts[$i] = $this->aliases[$aliasParts[$i]];
                }
            }
        }
        $alias = join( '.', $aliasParts );
        return $alias;
    }
959902
public function fetch( $alias ) {
		if ( isset( $this->classes[ $alias ] ) ) {
			// If the alias is a class name,
			// then retrieve its linked alias.
			// This is only registered when
			// registering using an array.
			$alias = $this->classes[ $alias ];
		}

		if ( ! isset( $this->aliases[ $alias ] ) ) {
			throw new UndefinedAliasException( $alias );
		}

		$value = $this->definitions[ $alias ];

		// If the shared value is a closure,
		// execute it and assign the result
		// in place of the closure.
		if ( $value instanceof \Closure ) {
			$factory = $value;
			$value   = $factory( $this );
		}

		// If the value is shared, save the shared value.
		if ( isset( $this->shared[ $alias ] ) ) {
			$this->definitions[ $alias ] = $value;
		}

		// Return the fetched value.
		return $value;
	}
814208
protected static function createEnvInstance(string $alias)
    {
        ## find alias names: dev->development ==> class_name
        $EnvClass = null;
        while(is_string($alias) && isset(static::$_aliases[$alias]))
            $EnvClass = $alias = static::$_aliases[$alias];

        if (is_string($EnvClass) && class_exists($EnvClass))
            $EnvClass = new $EnvClass();


        if (! $EnvClass instanceof EnvBase)
            throw new \Exception(sprintf(
                'Invalid Alias name provided. "%s".'
                , (is_callable($aliasOrCallable))
                ? \Poirot\Std\flatten($alias).' provided from Callable'
                : \Poirot\Std\flatten($alias)
            ));
        
        return $EnvClass;
    }
419796
public function getTable($alias)
    {
        // has factory ?
        if (isset($this->_table_factory[$alias])) return $this->_table_factory[$alias];

        $class_name = $this->config->getNamingStrategy()->aliasToTableClassName($alias);
        foreach ($this->config->getModelDirs() as $dir) {
            $class_full_name  = sprintf('%s\\%s', $dir['namespace'], $class_name);
            if (class_exists($class_full_name)) {
                $table = new $class_full_name($this);
                if ($container = $this->raikiri()) {
                    $table->setContainer($container);
                }
                $this->_table_factory[$alias] = $table;
                return $table;
            }
        }
        throw new Exception\EntityTableNotFoundException('no such table. -> ' . $alias);
    }
563857
public function getMappingByAlias(string $alias) : Mapping
    {
        foreach ($this->mappings as $mapping) {
            if (0 === strcasecmp($alias, $mapping->getClassAlias())) {
                return $mapping;
            }
        }

        return Mapping::null();
    }
377955
private function getNameByAlias($alias)
    {
        return isset($this->_contentMap[$alias]) ? $this->_contentMap[$alias] : $alias;
    }
503319
public function get($alias) {
        return !empty($this->routingTable[$alias]) ? $this->routingTable[$alias] : null;
    }
941965
public function getManagerNameByAlias($alias)
    {
        $aliasMap = $this->getModuleOptions()->getManagerAliases();
        if (!array_key_exists($alias, $aliasMap)) {
            $errMsg = sprintf('Invalid workflow manager alias: %s', $alias);
            throw new Exception\InvalidWorkflowManagerAliasException($errMsg);
        }

        return $aliasMap[$alias];
    }
832145
public function getStaffByAlias($alias) {
        $access = $this->getByAlias($alias);

        return $this->find('all', array(
            'conditions' => array(
                'RequestObject.parent_id' => $access['RequestObject']['id'],
                'RequestObject.foreign_key !=' => null,
                'RequestObject.model' => USER_MODEL
            ),
            'contain' => array('User', 'Parent'),
            'cache' => array(__METHOD__, $alias)
        ));
    }
423610
public function get($alias)
    {
        $alias = $this->normalizeNamespace($alias);

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

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

        throw new ModelException(sprintf('Model for entity "%s" does not exists', $alias));
    }
361419
protected function normalizeBoltName($alias)
    {
        $metadata = $this->loadMetadataForClass($alias);

        return $metadata ? $metadata->getBoltName() : null;
    }
562049
public function getFetcher($alias)
    {
        if (!is_string($alias)) {
            throw new UnexpectedTypeException($alias, 'string');
        }

        if (!isset($this->fetchers[$alias])) {
            throw new \InvalidArgumentException(sprintf('Could not load configuration fetcher "%s"', $alias));
        }

        return $this->fetchers[$alias];
    }
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;
    }