Returns a context parameter - $default if parameter is not found

@param   string  $parameter  The parameter to retrieve
@param   mixed   $default    The default value if $parameter is not found
@return  mixed
557678
protected function getContextParameter($parameter, $default = null)
    {
        $parameters    = $this->getContextParameters();
        if (array_key_exists($parameter, $parameters)) {
            return $parameters[$parameter];
        } else {
            return $default;
        }
    }
656003
public function get($key, $default = null)
    {
        if(strpos($key, '.')) {
            return $this->getRecursive($key, $default);
        }

        if (array_key_exists($key, $this->parameters)) {
            return $this->parameters[$key];
        } else {
            return $default;
        }
    }
1349620
protected function getParameter($name, $default = null)
    {
        return array_key_exists($name, $this->params)?$this->params[$name]:$default;
    }
935992
public function getParameter($parameterName, $defaultValue = null)
    {
        if ($this->getConfigResolver()->hasParameter($parameterName)) {
            return $this->getConfigResolver()->getParameter($parameterName);
        }

        return $defaultValue;
    }
822790
protected function getCookieParameter($parameter, ServerRequestInterface $request, $default = null)
    {
        return isset($request->getCookieParams()[$parameter]) ? $request->getCookieParams()[$parameter] : $default;
    }
1204788
protected function getRoutedParameter($parameter, $default = null)
    {
        $output = $default;

        $parameters = $this->route->getParameters();

        if (!empty($parameters->$parameter))
        {
            $output = $parameters->$parameter;
        }

        $validatedData = $this->route->getValidatedData();

        if (!empty($validatedData->$parameter))
        {
            $output = $validatedData->$parameter;
        }

        return $output;
    }
7484
public static function get(
        array $params,
        string $key,
        $default = null
    ) {
        if (self::has($params, $key)) {
            return $params[$key];
        }

        return $default;
    }
449003
public function getParameter($parameter)
    {
        return isset($this->getParameters()[$parameter]) ? $this->getParameters()[$parameter] : null;
    }
466891
public function get($key, $default = false)
    {
        $this->initializeOnDemand();

        if ($this->has($key)) {
            return $this->cache[$key][ConstProviderInterface::CACHE_PARAM_VALUE];
        } else {
            return $default;
        }
    }
211327
public function getParam(string $key, $default = null)
    {
        if (isset($this->post[$key])) {
            return $this->post[$key];
        }
        if (isset($this->get[$key])) {
            return $this->get[$key];
        }
        return $default;
    }
370922
public function getParameter($parameter) {
        $value = NULL;
        if ($parameter != NULL) {
            if (isset($this->params[$parameter])) {
                $value = $this->params[$parameter];
            }
        }
        if (is_null($value)) {
            if (isset($_POST[$parameter])) {
                $value = $_POST[$parameter];
            }
        }
        if (is_null($value)) {
            if (isset($_GET[$parameter])) {
                $value = $_GET[$parameter];
            }
        }
        if (is_string($value)) {
            $value = urldecode($value);
        }
        return $value;
    }
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;
    }
1197232
protected function getDefaultParametersFromContext($context = null)
    {
        if (count($this->defaultParameters['contexts'])) {
            //If context is not given, just take the default one
            if ($context === null) {
                $context = $this->defaultParameters['default']['context'];
            }

            //If context is in declared contexts, we use it
            if (array_key_exists($context, $this->defaultParameters['contexts'])) {
                return $this->defaultParameters['contexts'][$context];
            }
        }

        //else we return the default configuration
        return $this->defaultParameters['default'];
    }
1171564
public function getParam($param, $default = null) 
    {
        if(array_key_exists($param, $this->params)) {
            return $this->params[$param];
        }
        
        return $default;
    }
1158320
private function getParameterFromContext(array $context, string $parameterName, $default = null)
    {
        $filters = $context['filters'] ?? [];

        return \array_key_exists($parameterName, $filters) ? $filters[$parameterName] : $default;
    }
719482
public function getParameter($name, $default = NULL)
	{
		if (isset($this->params[$name])) {
			return $this->params[$name];

		} else {
			return $default;
		}
	}
1207151
protected function resolvePrimitive(ReflectionParameter $parameter)
    {
        if (! is_null($concrete = $this->getContextualConcrete('$'.$parameter->name))) {
            return $concrete instanceof Closure ? $concrete($this) : $concrete;
        }

        if ($parameter->isDefaultValueAvailable()) {
            return $parameter->getDefaultValue();
        }

        $this->unresolvablePrimitive($parameter);
    }