Gets an argument to pass to the service constructor/factory method.

@param int $index

@return mixed The argument value

@throws OutOfBoundsException When the argument does not exist
769443
public function getArgument($index)
    {
        if ($index < 0 || $index > count($this->arguments) - 1) {
            throw new OutOfBoundsException(sprintf('The index "%d" is not in the range [0, %d].', $index, count($this->arguments) - 1));
        }

        return $this->arguments[$index];
    }
1352458
public function get($index){
		if(isset($this->map[ $index ])){
			return $this->map[ $index ];
		}
		return null;
	}
720301
public function getParam($index){
        if(isset($this->params[$index])){
            return $this->params[$index];
        }else{
            return NULL;
        }
    }
652001
public function getAbstractNode( $index )
	{
		if ( ! isset( $this->_childs[ $index ] ) )
			throw new IndexOutOfRangeException();
		return $this->_childs[ $index ];
	}
83196
public function getParamClean($index){
        if(isset($this->params[$index])){
            return $this->params[$index];
        }else{
            return NULL;
        }
    }
281471
public function getArgument($index)
    {
        if (!is_int($index)) {
            throw new InvalidArgumentException('integer', 0);
        }

        if (!isset($this->arguments[$index])) {
            return null;
        }

        return $this->arguments[$index];
    }
868996
public function get($index)
    {
        if (!is_int($index) || $index < 0) {
            throw new \InvalidArgumentException('ItemList::get() expects a positive integer argument.');
        }

        return isset($this->list[$index]) ? $this->list[$index] : null;
    }
795316
public function getParameter($index) {
        $parameter = null;
        if ($this->hasParameter($index)) {
            $parameter = $this->_parameters[$index];
        }
        return $parameter;
    }
519117
public function get($index)
    {
        $index = intval($index);
        $i = 0;
        foreach ($this->getInnerIterator() as $v) {
            if ($i == $index) {
                return $v;
            }
            $i++;
        }

        return null;
    }
985780
public function get($index)
    {
        $config = $this->config;
        foreach (explode('.', $index) as $value) {
            $config = $config[$value];
        }

        return $config;
    }
300321
public function get($index): JWK
    {
        if (!$this->has($index)) {
            throw new InvalidArgumentException('Undefined index.');
        }

        return $this->keys[$index];
    }
901240
public function get_request_comp(int $index=null) {
		$comp = $this->request_comp;
		if ($index === null)
			return $comp;
		if (isset($comp[$index]))
			return $comp[$index];
		return null;
	}
1267037
public function offsetGet($offset)
    {
        if (false === array_key_exists($offset, $this->container)) {
            throw OutOfBoundsException::arrayKey($offset);
        }

        if (is_callable($this->container[$offset])) {
            return $this->container[$offset]($this);
        }

        return $this->container[$offset];
    }
1017569
public function offsetGet($index)
    {
        if (!$this->offsetExists($index)) {
            throw new \InvalidArgumentException('Writer "' . $index . '" does not exist');
        }

        return parent::offsetGet($index);
    }
148786
protected static function getCaller($index, $offset = 1): array
    {
        Assert::greaterThanEq($index, 0);

        $index += $offset + 1;

        $stack = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, $index + 1);
        if (! isset($stack[$index])) {
            throw new \OutOfBoundsException(sprintf('%s is greater than the current call stack', $index - $offset - 1));
        }
        $frame = $stack[$index];

        if (! isset($frame['class'])) {
            // Assert the function isn't called directly from a script,
            // else we would be saying "require() is deprecated" lol.
            if (! function_exists($frame['function'])) {
                $frame = $stack[$index - $offset];
                throw new \InvalidArgumentException(
                    sprintf('%s::%s() must be called from within a function/method.', $frame['class'], $frame['function'])
                );
            }

            return [
                $frame['function'],
                $frame['function'],
                false,
                false,
            ];
        }

        $class = $frame['class'];
        $function = $frame['function'];
        $constructor = $function === '__construct';

        if ($function === '__call' || $function === '__callStatic') {
            $frame = debug_backtrace(0, $index + 1)[$index]; // with args
            $function = $frame['args'][0];
        }

        return [
            $class . (! $constructor ? '::' . $function : ''),
            $function,
            $constructor,
        ];
    }
1105235
public function item(int $index)
    {
        return $this->offsetExists($index) ? $this->offsetGet($index) : null;
    }
280901
public function take($idx)
    {
        self::mustBeInteger($idx, 'Index');

        if ($idx instanceof N) {
            $idx = $idx->int;
        }

        if (!$this->exist($idx)) {
            throw new \OutOfRangeException(
                'Given '. $idx .' index does not exist!'
            );
        }

        return $this->value[$idx];
    }