Returns the repository if it is registered in the map, throws exception otherwise

@param   string      $key        The key
@return  RepositoryInterface
@throws  \OutOfBoundsException   If the key does not exist
183028
public function getRepository($key)
    {
        $repository = $this->tryGetRepository($key);
        if ($repository === null) {
            throw new \OutOfBoundsException($key.' does not exist in the registry');
        }
        return $repository;
    }
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];
    }
1134239
protected function transformKey($key)
    {
        list($namespace, $group, $item) = $this->repository->parseKey($key);
        if (!$namespace) {
            $namespace = $this->default_namespace;
        }

        $collection = "{$namespace}::{$group}";
        if ($item) {
            $collection .= ".{$item}";
        }

        return $collection;
    }
952398
public function getLast($primaryKey)
    {
        if (!isset($this->values[$primaryKey])) {
            throw new OutOfBoundsException(sprintf(
                'The key "%s" does not exist.',
                $primaryKey
            ));
        }

        return end($this->values[$primaryKey]);
    }
1023351
public function get($name)
    {
        if (array_key_exists($name, $this->queryDefinitionMap)) {
            return $this->queryDefinitionMap[$name];
        }

        throw new OutOfBoundsException(
            "Could not find QueryDefinition with name '{$name}'"
        );
    }
1007993
public function getRepository(string $key): OptionRepository
    {
        if (! $this->has($key)) {
            throw UnknownOptionKey::fromKey($key);
        }

        return $this->map[$key][self::SUBKEY_REPOSITORY];
    }
843980
public function get(string $key)
    {
        if (! $this->has($key)) {
            throw DependencyInjectionException::keyNotRegistered($key);
        }

        $value = $this->items[$key];

        if ($value instanceof Definition) {
            return $value->get($this);
        }

        return $value;
    }
640351
public function getInteger($key)
	{
		$resolved = false;
		$value = $this->getByKey($key, $this->data, $resolved);
		
		if($resolved)
		{
			return (int)$value;
		}
		
		if(func_num_args() > 1)
		{
			return func_get_arg(1);
		}
		
		throw new \OutOfBoundsException('Configuration setting not found: "' . $key . '"');
	}
1316169
public static function get($key)
    {
        $key = strtoupper($key);

        $list = static::loadConstants();

        if(array_key_exists($key,$list))
            return static::loadConstants()[$key];

        if(static::exist($key))
            return $key;

        // Throw exception.
        static::invalidType();
    }
18167
public function getMap($mapName)
    {
        if (isset($this->maps[$mapName]))
            return $this->maps[$mapName];

        throw new \OutOfBoundsException("There is no map registered with the name \"$mapName\"");
    }
566982
protected function getResolver(string $key): ?ResolverInterface
    {
        foreach ($this->getResolvers() as $resolver) {
            if ($resolver->hasService($key) === true) {
                return $resolver;
            }
        }

        return null;
    }
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];
    }
245096
public function get($key)
    {
        if (!$this->offsetExists($key)) {
            throw new InvalidArgumentException(sprintf('Identifier "%s" is not defined.', $key));
        }
        return $this->offsetGet($key);
    }
830721
public function get(string $key)
    {
        $keyMD5 = md5($key);
        $value = $this->dataRepository->getValue($this->keyPrefix . substr($keyMD5, 0, 3) . '/' . substr($keyMD5, 3) . '.2');
        if ($value !== null) {
            try {
                $value = unserialize(gzuncompress($value));
                if ($value[0] > 0) {
                    if ($value[0] > time()) {
                        return $value[1];
                    }
                    return null;
                }
                return $value[1];
            } catch (\Exception $e) {
                
            }
        }
        return null;
    }
67839
public static function get($key)
    {
        self::getInstance();

        if (array_key_exists($key, self::$settings))
        {
            return self::$settings[$key];
        }

        throw new \InvalidArgumentException("The key $key doesn't exist in the Config Registry.");
    }
1239150
public function getScore($key)
    {
        if (! array_key_exists($key, $this->scores)) {
            throw new \OutOfBoundsException('The key "' . $key . ' was not found.');
        }
        
        return $this->scores[$key];
    }
422391
private function getUsingInternalProperty($key)
    {
        $value = false;

        if (
            array_key_exists($key, $this->internal_property_accessible) &&
            $this->internal_property_accessible[$key]
        ) {
            if ($this->hasSubDataObject($key)) {
                // return loaded sub-dataobject
                $value = $this->getSubDataObject($key);
            } elseif ($this->hasInternalValue($key)) {
                $value = $this->getInternalValue($key);

                if (
                    $value !== null &&
                    isset($this->internal_property_classes[$key])
                ) {
                    // autoload sub-dataobject
                    $class = $this->internal_property_classes[$key];

                    if (!class_exists($class)) {
                        throw new SwatClassNotFoundException(
                            sprintf(
                                "Class '%s' registered for internal property '%s' " .
                                    "does not exist.",
                                $class,
                                $key
                            ),
                            0,
                            $class
                        );
                    }

                    $this->checkDB();

                    $object = new $class();
                    $object->setDatabase($this->db);
                    $object->load($value); // autoload
                    $this->setSubDataObject($key, $object);

                    $value = $object;
                }
            }
        }

        return $value;
    }