@brief Search the current Section for a field by it's alias

@param string $alias The alias to search for.

@return null|ObjectField The field if found, or null.
510964
public function getFieldByAlias($alias)
    {
        foreach ($this->_fields as $column => $fields)
        {
            foreach ($fields as $field)
            {
                if ($field->getAlias() === $alias)
                {
                    return $field;
                }
            }
        }
        return null;
    }
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)
        ));
    }
841260
protected function get_component_select_sql($alias = '') {
        $component = $this->get_component();
        if ($alias) {
            $alias = $alias.'.';
        }
        if (empty($component)) {
            $componentwhere = "{$alias}component IS NULL";
            $component = null;
        } else {
            $componentwhere = "({$alias}component IS NULL OR {$alias}component = :component)";
        }
        return array($componentwhere, $component);
    }
534332
protected function resolveAlias($alias)
	{
		if (!empty($this->aliases[$alias]))
		{
			return $this->aliases[$alias];
		}

		return $alias;
	}
1156438
public function fields(array $fields, string $alias = null): Select
    {
        $alias = ($alias === null) ? '' : "{$alias}.";

        foreach ($fields as $field => $as) {
            if (is_numeric($field)) {
                $this->field($alias . $as);
            } else {
                $this->field($alias . $field, $as);
            }
        }

        return $this;
    }
238008
public function alias(string $alias): AliasInterface
    {
        if (!in_array($alias, $this->alias)) {
            $this->alias[] = $alias;
        }
        $this->aliasHelper($alias);

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

		return $alias;
	}
820929
public static function getAlias($alias)
    {
        $alias = strtolower($alias);

        return array_key_exists($alias, self::$aliases) ? self::$aliases[$alias] : false;
    }
110103
public function getProvider($alias)
    {
        if (array_key_exists($alias, $this->providers)) {
            return $this->providers[$alias];
        }

        return null;
    }
352629
public function get($alias)
    {
        if (!isset($this->registered[$alias]))
            return false;
        
        // Does an instance exist for this alias?
        if (isset($this->instance[$alias]) && is_object($this->instance[$alias]))
            return $this->instance[$alias];
        
        // Execute the Closure to get the first instance
        $this->instance[$alias] = $this->registered[$alias]($this);
        if (!is_object($this->instance[$alias]))
            throw new Exception('The alias "' . $alias . '" does not return an object.');
        
        return $this->instance[$alias];
    }
1008846
public function getConfiguration($alias)
    {
        if (array_key_exists($alias, $this->searchConfigurations)) {
            return $this->searchConfigurations[$alias];
        }

        return null;
    }
664543
private function getResolver($alias)
    {
        if (!in_array($alias, $this->supportedAdapters)) {
            return null;
        }

        if (!isset($this->resolvers[$alias])) {
            $this->resolvers[$alias] = $this->createResolver($alias);
        }

        return $this->resolvers[$alias];
    }
883483
final public function getIndex(string $alias): ?GlobalSecondaryIndex
    {
        $this->loadIndexes();
        return $this->gsi[$alias] ?? null;
    }
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;
    }
504117
final public function hasInstance(string $alias): bool
    {
        if (!$this->has($alias)) {
            return false;
        }

        while (isset($this->bindings[$alias]) && is_string($this->bindings[$alias])) {
            //Checking alias tree
            $alias = $this->bindings[$alias];
        }

        return isset($this->bindings[$alias]) && is_object($this->bindings[$alias]);
    }
1077950
public function get($alias)
    {
        return isset($this->services[$alias]) ? $this->services[$alias] : null;
    }
956989
public function resolve($alias): ?Type
    {
        if (null === $alias) {
            return null;
        }

        if (!isset($this->cache[$alias])) {
            $type = $this->string2Type($alias);
            $this->cache[$alias] = $type;
        }

        return $this->cache[$alias];
    }