Retorna informações do XML com base no caminho separado por ponto.

@param $key
@return XMLGet
322756
public function get($key)
    {
        if (Str::contains($key, '|')) {
            $opcoes = explode('|', $key);
            foreach ($opcoes as $op) {
                $achado = $this->get($op);
                if (! $achado->isNull()) {
                    return $achado;
                }
            }

            return new XMLGet(null);
        }

        $base = $this;
        $niveis = ($key == '') ? [] : explode('.', $key);

        foreach ($niveis as $i => $nivel) {

            // Verificar se base eh nula
            if (is_null($base)) {
                return new XMLGet(null);
            }

            $elem = $base->getElementsByTagName($nivel);
            $base = ($elem->length > 0) ? $elem->item(0) : null;
        }

        // Retornar o conteúdo do ultimo nível
        if (! is_null($base)) {
            return new XMLGet($base);
        }

        return new XMLGet(null);
    }
1257275
protected function getRepository($key)
    {
        $rep = $this->entityRepositories[$key];
        if ($rep) {
            return $this->getEntityManager()->getRepository($rep);
        }
    }
1073630
public function withoutAttribute($key)
    {
        $newAttributes = $this->attributes->withoutAttribute($key);
        $that = clone($this);
        $that->attributes = $newAttributes;
        return $that;
    }
698821
protected function &getAttributeValue(string $key)
    {
        if (isset($this->attributes[$key])) {

            return $this->attributes[ $key ];
        }

        $null = null;

        return $null;
    }
1192877
public function &offsetGet($key)
    {
        if (!isset($this->storage[$key])) {
            $this->storage[$key] = null;
        }

        return $this->storage[$key];
    }
1205327
protected function loadEntity($key)
    {
        $content = $this->getFileManager()->read($key);
        if($content) {
            return unserialize($content);
        }
        
        return null;
    }
467272
public function getEntityAttribute(string $key)
    {
        if ($this->isRawEntityAttribute($key)) {
            return $this->getEntityAttributeRelation($key);
        }

        return $this->getEntityAttributeValue($key);
    }
1033808
public function get($key)
    {
        $yaml = $this->getContent();

        return isset($yaml['parameters']) && isset($yaml['parameters'][$key]) ? $yaml['parameters'][$key] : '';
    }
1002567
public function get($key)
    {
        $value = $this->apc->get($this->prefix.$key);

        if ($value !== false) {
            return $value;
        }
    }
1102849
public function getConnectionByKey($key)
    {
        $hash = $this->strategy->getSlotByKey($key);
        $node = $this->distributor->getBySlot($hash);

        return $node;
    }
1222383
public function getAttribute($key)
    {
        if ($this->isBaseAttribute($key))
        {
            return parent::getAttribute($key);
        } else
        {
            return $this->getSource()->getAttribute($key);
        }
    }
317642
protected function getDocument($key)
    {
        if (!$this->documentExists($key)) {
            return null;
        }

        return $this->convertDocument($this->documents[$key]);
    }
1071026
public function make($key)
    {
        switch ($key) {
            case 'config': return $this->config;
            case 'em': return $this->entityManager;
            case 'extension': return $this->extensionManager;
            case 'migration': return $this->migrationManager;
            case 'log': return $this->logger;
            case 'file': return $this->files;
            default: return $this;
        }
    }
897158
public function loadByKey($key)
    {
        $configuration = new Configuration();
        require $key;
        $vars = get_defined_vars();
        unset($vars['configuration']);
        unset($vars['key']);
        foreach ($vars as $name => $value) {
            $configuration->{$name} = $value;
        }

        return $configuration;
    }
209070
public static function get($key)
    {
        if ( self::exists($key) ) {
            $key = explode('.', $key);
            $array = self::$arr[$key[0]];
            unset($key[0]);

            foreach ( $key as $k ) {
                $array = $array[$k];
            }

            return $array;
        } else {
            echo '<b>N&atilde;o existe o &iacute;ndice informado no array.</b>';
            return false;
        }
    }
658969
protected function xml($key = null, $default = null)
    {
        if (empty($this->contentAsArray)) {
            $content = $this->getContent();
            $data = DataFormatter::xmlToArray($content);

            if (!empty($data)) {
                if ((1 === count($data)) && !array_key_exists(ResourcesWrapper::getWrapper(), $data)) {
                    // All XML comes wrapped in a single wrapper, if not resource wrapper, remove it
                    $data = reset($data);
                }

                $this->contentAsArray = $data;
            }
        }

        if (null === $key) {
            return $this->contentAsArray;
        } else {
            return array_get($this->contentAsArray, $key, $default);
        }
    }
1190924
public static function get(string $key)
    {
        if (!in_array($key, self::$allowedKeys) || !isset(self::$storedValues[$key])) {
            throw new \InvalidArgumentException('Invalid key given');
        }

        return self::$storedValues[$key];
    }