@param string $key

@throws \OutOfBoundsException If the key does not exist

@return mixed
321192
public function get($key)
    {
        if (!array_key_exists($key, $this->properties)) {
            throw new \OutOfBoundsException(sprintf('Key "%s" does not exist', $key));
        }

        return $this->properties[$key];
    }
1192704
public function get($key)
    {
        $config = $this->getConfig();
        if (! array_key_exists($key, $config)) {
            throw new \OutOfRangeException(sprintf(self::ERR_INVALID_CONFIG_KEY, $key));
        }
        return $config[$key];
    }
839989
public function getObject($key)
    {
        if (false === $this->hasId($key)) {
            throw new \OutOfBoundsException('no id=' . $key . ' at the identity-map');
        }

        return $this->idToObject[$key];
    }
835746
public function getOneByKey($key)
	{
		// Note: this switch exists like this because PHP does not have "traditional method overloading".
		switch(gettype($key))
		{
			// Use EntityIdentifier to retrieve.
			case 'object':
				return $this->getOneByIdentifier($key);
			break;

			// Use a composite key to retrieve.
			case 'array':
				return $this->getOneByCompoundKey($key);
			break;

			// Use an actual Identifier string to retrieve.
			case 'string':
				return $this->getOneByUuid($key);
			break;

			// Use Entity to retrieve.
			default:
				return new Payload($key, 'invalid_key_type');
		}
	}
1328887
public function get($key)
    {
        $data = $this->connection()->get($this->prefix.$key);

        if (!is_null($data)) {
            return (is_numeric($data)) ? $data : unserialize($data);
        }
    }
913825
protected function fetch(string $key)
    {
        if (!isset($this->data[$key])) {
            return;
        }

        // Reset timer if there was an expiration.
        if (isset($this->timers[$key])) {
            $this->timers[$key]->again();
        }

        return $this->data[$key];
    }
732288
public function get($key)
    {
        if (!$this->offsetExists($key)) {
            throw new UnexpectedValueException(sprintf('Unknown key %s.', $key));
        }

        return $this->offsetGet($key);
    }
1291233
public function getKey(string $key)
    {
        $keys = explode('.', $key);
        $file = array_shift($keys);
        $keys = explode('/', implode('.', $keys));

        if (!isset($this->translations[$file])) {
            $this->addFile($file);
        }

        return $this->findKey($file, $keys);
    }
862497
protected function fetchKey($key)
    {
        if (str_contains($key, '.'))
        {
            $keys = explode('.', $key);
            $search = array_except($keys, 0);

            return array(array_get($keys, 0), implode('.', $search));
        }

        return array($key, null);
    }
994831
public function offsetGet($offset)
    {
        if (! $this->offsetExists($offset)) {
            throw new \OutOfBoundsException(
                sprintf(
                    'Key %s does not exists',
                    $offset
                )
            );
        }

        return $this->data[$offset];
    }
1077124
public function get(string $key)
    {
        $slug = $this->splitKey($key);

        if (is_string($slug)) {
            if (isset($this[$slug])) {
                return $this[$slug];
            }
            return null;
        }

        $array = $this->toArray();

        foreach ($slug as $search) {
            if (isset($array[$search])) {
                $array = $array[$search];
            } else {
                return;
            }
        }

        return $array;
    }
1129471
public function get(string $key)
    {
        if ($this->replacedPayload) {
            if (! \array_key_exists($key, $this->payload)) {
                throw new \BadMethodCallException("Message payload of {$this->messageName()} does not contain a key $key.");
            }

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

        if ($key !== self::MESSAGE) {
            throw new \BadMethodCallException(__CLASS__ . ' payload only contains a ' . self::MESSAGE . ' key.');
        }

        return $this->message;
    }
570608
public function getRequired(string $key)
    {
        if (!$this->has($key)) {
            throw new \InvalidArgumentException('Element ' . $key . ' does not exist');
        }

        return $this->collection[$this->keyMap[strtolower($key)]];
    }
1188536
public function get(?string $key = null)
    {
        $key = $this->constructKey($key);

        if (is_null($key)) {
            $array = $this->toArray();

            return $this->count() == 1 ? end($array) : $array;
        }

        return $this->parseKey($key, function ($part, $result) {
            if (isset($result[$part])) {
                return $result[$part];
            }
        });
    }
103230
public function &get($key)
	{
		$out = ($this->exists($key)) ? $this->meta[$key] : false;
		return $out;
	}
281408
public function get(string $key)
    {
        if (!isset($this->data[$key])) {
            return null;
        }

        $struct = $this->data[$key];

        if ($struct->ttl !== null) {
            $expire = \time() + $struct->ttl;
            if ($struct->expire < $expire) {
                $struct->expire = $expire;
                $this->queue->insert([$key, $struct->expire], -$struct->expire);
            }
        }

        return $struct->data;
    }
1349882
public function computeKey($path)
    {
        if (0 !== strpos($path, $this->directory)) {
            throw new \OutOfBoundsException(sprintf('The path \'%s\' is out of the filesystem.', $path));
        }

        return ltrim(substr($path, strlen($this->directory)), '/');
    }