Get an application parameter.

@param string $parameter

@return mixed
767130
public function getParameter($parameter)
    {
        return $this->container->hasParameter($parameter) ? $this->container->getParameter($parameter) : null;
    }
106393
public function get($parameter=null) {

        if ( is_null($parameter) ) return $this->parameters;

        return $this->getFromParts(self::splitParts($parameter));

    }
867271
public function get(string $name): Parameter
    {
        if (!$this->has($name)) {
            //Automatically creating constant
            $parameter = new Parameter($name);
            $this->add($parameter);

            return $parameter;
        }

        return parent::get($name);
    }
814496
public function getParameter($name)
    {
        $name = (string)$name;
        return array_key_exists($name, $this->_params) ? $this->_params[$name] : null;
    }
248033
private function getSession($parameter)
    {
        $factory = new RepositoryFactoryJackrabbit();
        $repository = $factory->getRepository(array('jackalope.jackrabbit_uri' => $parameter['jackrabbit_uri']));
        $credentials = new SimpleCredentials($parameter['user'], $parameter['password']);

        return $repository->login($credentials, $parameter['workspace']);
    }
702045
public function get($parameter = null) {

        if ( empty($parameter) ) {

            $return = $this->parameters;

        } else if ( array_key_exists($parameter, $this->parameters) ) {

            $return = $this->parameters[$parameter];

        } else {

            $return = null;

        }

        return $return;

    }
996204
public function getParameter($key) {
		if (array_key_exists ( $key, $this->parameters ))
			return $this->parameters [$key];
		else
			return null;
	}
557678
protected function getContextParameter($parameter, $default = null)
    {
        $parameters    = $this->getContextParameters();
        if (array_key_exists($parameter, $parameters)) {
            return $parameters[$parameter];
        } else {
            return $default;
        }
    }
1280448
private function getArgumentByName(\ReflectionParameter $parameter, $parameters)
    {
        foreach ($parameters as $name => $item) {
            $paramName = $parameter->getName();
            if ($name === $paramName) {
                return $item;
            }
        }

        return null;
    }
8965
public function handle(\ReflectionParameter $parameter)
    {
        $func = $parameter->getDeclaringFunction();
        $method = new \ReflectionMethod($parameter->getDeclaringClass()->name, $func->name);
        $parameter->getDeclaringFunction()->name;
        $annotations = $this->reader->getMethodAnnotations($method);
        foreach ($annotations as $annotation) {
            if ($annotation instanceof ResourceParam && $annotation->param === $parameter->name) {
                return $this->getResourceParam($annotation->uri);
            }
        }
        (new VoidParamHandler)->handle($parameter);
    }
173450
public function getParameter($parameter, $default = null)
    {
        if (!isset($this->parameters[$parameter])) {
            return $default;
        }

        return $this->parameters[$parameter];
    }
1276198
protected function get($parameter, $default=null) {
		return isset($this->parameters[$parameter]) ? $this->parameters[$parameter] : $default;
	}
705016
public function getParameter($parameter)
    {
        if ($this->hasParameter($parameter)) {
            return ArrayUtils::get($this->parameters, $parameter);
        }

        if (array_key_exists($parameter, $this->mapping) && ArrayUtils::has($this->parameters, $this->mapping[$parameter])) {
            return ArrayUtils::get($this->parameters, $this->mapping[$parameter]);
        }

        //otherwise let's go default
        $defaults = [];
        foreach ($this->defaultConfigs as $default) {
            $defaults = array_merge($default, $defaults);
        }

        if (array_key_exists($parameter, $defaults)) {
            return ArrayUtils::get($defaults, $parameter);
        }

        if (array_key_exists($parameter, $this->mapping) && ArrayUtils::has($defaults, $this->mapping[$parameter])) {
            return ArrayUtils::get($defaults, $this->mapping[$parameter]);
        }

        return null;
    }
531125
public function grabFromConfig($parameter)
    {
        if (!isset($this->config[$parameter])) {
            throw new ModuleConfigException(get_class($this), sprintf(
                'Parameter "%s" is not specified in module\'s configurations.',
                $parameter
            ));
        }

        return $this->config[$parameter];
    }
442035
public static function make(string $parameter): string
	{
		$parameter = str_replace('.', '_', $parameter);
		$parameter = str_replace(',', '_', $parameter);
		$parameter = str_replace(' ', '_', $parameter);
		$parameter = str_replace('-', '_', $parameter);
		$parameter = str_replace('(', '', $parameter);
		$parameter = str_replace(')', '', $parameter);
		$parameter = str_replace('*', '', $parameter);
		$parameter = str_replace('>', '_', $parameter);
		$parameter = str_replace('<', '_', $parameter);
		$parameter = str_replace('\'', '', $parameter);
		$parameter = str_replace('"', '', $parameter);
		$parameter = str_replace('__', '_', $parameter);
		$parameter = str_replace(':', '_', $parameter);

		return strtolower($parameter) . static::getNextIndex();
	}
1149999
private function validateParameter(\ReflectionParameter $parameter)
    {
        $catcher = function ($className) {
            $generator = $this->generator($className);
            if ($generator) {
                include $generator->generate();
            }
        };
        
        if (($reflectionClass = $parameter->getDeclaringClass())
            && ($reflectionMethod = $parameter->getDeclaringFunction())) {
            $type = $this->typeHintIndex->lookup(
                $reflectionClass->getName(),
                $reflectionMethod->getName(),
                '$' . $parameter->getName()
            );

            if ($type && !class_exists($type) && !interface_exists($type)) {
                $catcher($type);
                return $this;
            }
        }

        spl_autoload_register($catcher);
        try {
            $parameter->getClass();
        } catch (\ReflectionException $e) {
            // Ignore reflection exception, as it is an intended behaviour for our catcher
        }
        spl_autoload_unregister($catcher);
        return $this;
    }
505850
private function getParameterValue(array $parameter, $name, $default = null)
    {
        if (!array_key_exists($name, $parameter)) {
            return $default;
        }

        return $parameter[$name]->getValue();
    }