Returns config parameter value.

@param mixed      $parameter A configuration parameter name
@param mixed|null $default   A default value if not found

@return mixed
550247
public function get($parameter, $default = null)
    {
        if ('link' == $parameter) {
            return $this->getLink();
        }

        return isset($this->config[$parameter]) ? $this->config[$parameter] : $default;
    }
194269
public function getConfig($key = null, $default = null)
    {
        return $this->formHelper->getConfig($key, $default, $this->formConfig);
    }
12538
public function get($key, $default = null)
    {
        $config = $this->config;

        foreach (explode('.', $key) as $k) {
            if (! isset($config[$k])) {
                return $default;
            }
            $config = $config[$k];
        }

        return $config;
    }
33375
public function getConfig($name, $default = null)
    {
        $value = $this->config->get($name);

        return $value === null ? $default : $value;
    }
664775
public function getParameter($parameter)
    {
        $isRefreshed = false;

        if (!$this->cacheExists()) {
            $this->refresh();
            $isRefreshed = true;
        }

        $values = parse_ini_file($this->cachePath);
        $return = null;

        if (isset($values[$parameter])) {
            $return = $values[$parameter];
        } else {
            if (!$isRefreshed) {
                $this->refresh();
                $values = parse_ini_file($this->cachePath);

                if (isset($values[$parameter])) {
                    $return = $values[$parameter];
                }
            }
        }

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

		} else {
			return $default;
		}
	}
449003
public function getParameter($parameter)
    {
        return isset($this->getParameters()[$parameter]) ? $this->getParameters()[$parameter] : null;
    }
806879
public function getParam($name, $default = null)
    {
        $params = $this->_context->params;
        return isset($params[$name]) ? $params[$name] : $default;
    }
99093
protected function _parameter_default($key, $default = NULL)
	{
		if ( ! array_key_exists($key, $this->_parameters))
		{
			return $default;
		}
		return $this->_parameters[$key];
	}
1307760
public function getParam($key, $default = null)
    {
        if (isset($this->parameters[$key])) {
            return $this->parameters[$key];
        }

        return $default;
    }
230121
public function get(string $parameter, $default = null)
    {
        if (false === $this->container->hasParameter($parameter)) {
            return $default;
        }

        if (null === $value = $this->container->getParameter($parameter)) {
            return $default;
        }

        return $value;
    }
776783
public function getConfParam($param, $default = null)
    {
        if (isset($this->params[$param])) {
            return $this->paymentHandler->formatConfigParam($param, $this->params[$param]);
        } elseif (isset($default)) {
            return $default;
        } else {
            throw new Exception("Configuration parameter '$param' not set for adapter '" . $this->name . "'");
        }
    }
325197
public function getParam($name, $default = null)
    {
        $value = array_get($this->params, $name);
        if ($value === null) {
            if ($default === null) {
                throw new InvalidValueException(['`:param` param is not exists in $configure->params', 'param' => $name]);
            } else {
                return $default;
            }
        } else {
            return $value;
        }
    }
318494
protected function getRequestParameter($parameter, ServerRequestInterface $request, $default = null)
    {
        $requestParameters = (array) $request->getParsedBody();

        return $requestParameters[$parameter] ?? $default;
    }
866599
private function determineParamValue(\ReflectionParameter $parameter)
    {
        $class = $parameter->getClass();

        if (!empty($class)) {
            // If this is a object we may be able to map it to something in our context
            $className = $class->getName();

            // Determine strong type-based link
            if (isset($this->instances[$className])) {
                return $this->instances[$className];
            }

            // Determine weak type-based link
            if (isset($this->weakLinks[$className])) {
                $lowerClassName = $this->weakLinks[$className];
                return $this->instances[$lowerClassName];
            }
        } else {
            // If this is a primitive type, attempt to determine it by its name
            $varName = $parameter->getName();

            if (isset($this->variablesByName[$varName])) {
                return $this->variablesByName[$varName];
            }
        }

        // We were unable to determine a suitable value based on this context. Pass back its default value if possible.
        if ($parameter->isDefaultValueAvailable()) {
            return $parameter->getDefaultValue();
        }

        // As a final fallback we will primitive pass NULL and let the function deal with it.
        return null;
    }
465272
public static function getConfigValue( $config, $key, $default = NULL )
	{
		if( !isset( $config[$key] ) )
			return $default;
		$value	= trim( $config[$key] );
		if( preg_match( '/^[A-Z_]+$/', $value ) )
			$value	= constant( $value );
		else if( preg_match( '/^[0-9]+$/', $value ) )
			$value	= (int) $value;
		else if( preg_match( '/^[0-9.]+$/', $value ) )
			$value	= (real) $value;
		else if( empty( $value ) )
			return $default;
		return $value;
	}
175186
public function getParameter($key, $default = null, $domain = null)
    {
        if ($domain) {
            return isset($this->config[$domain][$key])  ? $this->config[$domain][$key] : $default;
        }

        return isset($this->config[$key])  ? $this->config[$key] : $default;
    }