Retrieves offset value

@param string $alias

@return ModelInterface
@throws ModelException
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));
    }
823454
public static function query($alias = null, $model = null)
    {
        if (!$model) {
            $model = Di::getDefault()->getShared(static::class);
        }

        return $model->_di->get('ManaPHP\Mongodb\Query')->setModel($model)->setTypes($model->getFieldTypes());
    }
995368
public function offsetGet($offset)
    {
        if (!is_scalar($offset)) {
            throw new InvalidArgumentException('scalar', 0);
        }
        if (!$this->offsetExists($offset)) {
            throw new \DomainException("$offset is not set");
        }
        return $this->children[$offset];
    }
177248
public function getDomain($alias) {
		if (isset($this->aliases[$alias])) {
			return $this->aliases[$alias];
		}
		return $alias;
	}
918254
public function createResultSetMappingBuilder($alias)
    {
        $rsm = new ResultSetMappingBuilder($this->_em, ResultSetMappingBuilder::COLUMN_RENAMING_INCREMENT);
        $rsm->addRootEntityFromClassMetadata($this->_entityName, $alias);

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

        return Mapping::null();
    }
561494
public function getConvertedValue($alias = null)
    {
        if ($alias && isset($this->convertedAliasValue[$alias])) {
            return $this->convertedAliasValue[$alias];
        } else {
            return $this->convertedValue;
        }
    }
465090
public function offsetGet($name)
    {
        if (is_int($name)) {
            return parent::offsetGet($name);
        }
        $name = strtoupper($name);

        if (!isset($this->parameters[$name])) {
            return;
        }

        return $this->parameters[$name];
    }
554445
public function getSubqueryByAlias($alias)
    {
        return $this->hasSubqueryAlias($alias) ? $this->getExpression($this->getHash($alias)) : 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];
    }
342051
public static function get($alias) {
        if (isset(self::$pool[$alias])) {
            return self::$pool[$alias];
        }
        return null;
    }
1221723
public function getCardByAlias($alias)
    {
        if (!array_key_exists($alias, $this->aliases)) {
            throw new Exception\NoSuchAliasException(sprintf('Alias "%s" has not been assigned to any cards.', $alias));
        }

        return $this->getCard($this->aliases[$alias]);
    }
45893
public function offsetGet($offset)
    {
        return isset($this->lines[$offset]) ? $this->lines[$offset] : null;
    }
740750
public function get($alias, array $args = [])
    {
        $alias    = $this->inflectClassName($alias);
        $instance = NULL;

        // If we already have a shared instance, return it now
        if ( array_key_exists($alias, $this->sharedInstances) ) {
            return $this->sharedInstances[ $alias ];
        }

        // If we have an alias for this class get that
        if ( array_key_exists($alias, $this->aliases) ) {
            $instance = $this->get($this->aliases[ $alias ], $args);
        }

        // If the class is a callable
        if ( array_key_exists($alias, $this->callables) ) {
            $instance = $this->call($alias, $args);
        }


        // If we don't have an instance, create it now
        if ( !$instance ) {
            $instance = parent::get($alias, $args);
        }

        // If we should store a copy of this instance, do it now
        if ( in_array($alias, $this->toShare) ) {
            $this->sharedInstances[ $alias ] = $instance;
        }

        return $instance;
    }
236320
public function findByAlias(string $alias): ?Tag
    {
        /** @var TagModel $adapter */
        $adapter = $this->framework->getAdapter(TagModel::class);

        $criteria = $this->getCriteria();
        $criteria['alias'] = $alias;

        if (null === ($model = $adapter->findOneByCriteria($criteria))) {
            return null;
        }

        return ModelCollection::createTagFromModel($model);
    }
213247
public function getTableFromAlias(string $alias) : \Dms\Core\Persistence\Db\Schema\Table
    {
        if ($this->alias === $alias) {
            return $this->table;
        }

        foreach ($this->joins as $join) {
            if ($join->getAlias() === $alias) {
                return $join->getTable();
            }
        }

        throw InvalidArgumentException::format(
            'Invalid alias supplied to %s: expecting one of (%s), \'%s\' given',
            __METHOD__, Debug::formatValues($this->getAliases()), $alias
        );
    }
826977
public function get($alias)
    {
        if (false === $this->has($alias)) {
            throw new DataSetTransformerNotFoundException($alias);
        }

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