Returns the arguments for the given layer.

@param string $name

@return array An array where keys are the argument values and values are Cost instances
357980
public function getLayer($name)
    {
        if (null === $this->data) {
            $this->initializeProfile();
        }

        if (!is_array($this->data['layers'])) {
            return array();
        }

        $arguments = array();
        foreach ($this->data['layers'] as $key => $layer) {
            if ($name !== $layer) {
                continue;
            }

            foreach ($this->data['arguments'][$key] as $value => $cost) {
                $arguments[$value] = new Cost($cost);
            }
        }

        return $arguments;
    }
1361475
public function getValue($name)
	{
		if (! isset($this->values[$name]))
		{
			$this->values[$name] = arg($name);
		}

		return $this->values[$name];
	}
1303233
public function get(Name $name)
    {
        if (!$this->arguments->contains((string) $name)) {
            throw new ArgumentNotDefined((string) $name);
        }

        if (!$this->values->contains((string) $name)) {
            throw new ArgumentNotProvided($this->arguments->get((string) $name));
        }

        return $this->values->get((string) $name);
    }
798243
public static function getOptions(string $name): array
    {
        if (isset(self::$options) && is_array(self::$options))
            return self::$options[$name];
        return [];
    }
394725
protected function getArg ($name)
	{
		if (isset ($this->request['json']->$name))
		{
			return $this->getJSONArg ($name);
		}
		else
		{
			return parent::getArg ($name);
		}
	}
1293724
protected function getArg ($name)
	{
		
		// Work out which request arguments to use based on the request method
		
		switch ($this->action)
		{
			
			case 'get';
			case 'put':
				return $this->getURLArg ($name);
				break;
			
			case 'post';
			case 'delete':
				return $this->getPostArg ($name);
				break;
			
			default:
				return parent::getArg ($name);
				break;
			
		}
		
	}
1254701
public function getFieldsByName($name)
    {
        $result = [];

        foreach ($this->fields as $field) {
            if ($field->getName() == $name) {
                $result[] = $field;
            }
        }

        return $result;
    }
395430
public function parseTable($name): array
    {
        if ($name instanceof Model) {
            return [$name->alias(), $name->name()];
        }

        if (is_array($name)) {
            return [key($name), current($name)];
        }

        if (is_scalar($name)) {
            return static::parseName($name);
        }

        return [null, $name];
    }
1080357
public function findArgument($name) {
        foreach ($this->getArguments() as $argument) {
            if ($argument->getName() === $name) {
                return $argument;
            }
        }

        throw new ArgumentNotFoundException(s(
            'Argument "%s" does not exist.',
            $name
        ));
    }
887797
protected function get($name) {
$current = $this->env;

$isArguments = $name == $this->vPrefix . 'arguments';
while ($current) {
if ($isArguments && isset($current->arguments)) {
return array('list', ' ', $current->arguments);
}

if (isset($current->store[$name]))
return $current->store[$name];
else {
$current = isset($current->storeParent) ?
$current->storeParent : $current->parent;
}
}

$this->throwError("variable $name is undefined");
}
1102163
public function get($name)
    {
        if (!array_key_exists($name, $this->options)) {
            throw new \InvalidArgumentException(sprintf('The option "%s" does not exist.', $name));
        }

        return $this->options[$name];
    }
768861
public function &get($name)
    {
        if (!isset($this->mergedSettings[$name])) {
            $this->mergedSettings[$name] = array();
        }

        $result =& $this->mergedSettings[$name];
        return $result;
    }
258812
private function optionHasArgument($name)
    {
        foreach ($this->optionList as $option) {
            if ($option->matches($name)) {
                return $option->mode() != Getopt::NO_ARGUMENT;
            }
        }
        return false;
    }
333
public function getInfo($name)
    {
        $keys = explode('.', $name);
        if (is_array($keys)) {
            $file = array_shift($keys);
            $key = implode('.', $keys);
        } else {
            $file = $name;
            $key = null;
        }

        return ['file' => $file, 'key' => $key];
    }
815360
public function fetchParams(string $name): array
    {
        $bag = $this->request->request;

        return $bag->has($name) ? $bag->get($name, []) : $bag->all();
    }
135561
public function getMetadataIntersectArray($name)
    {
        $data = array();
        foreach ($this->getDataTables() as $childTable) {
            $childData = $childTable->getMetadata($name);
            if (is_array($childData)) {
                $data = array_intersect($data, $childData);
            }
        }
        return array_values($data);
    }
129430
public final function getHeader($name): array
   {
       $key = $this->parseHeaderName($name);
       return array_key_exists($key, $this->header) ? $this->header[$key] : [];
   }