Returns a request parameter unencoded

@param string $paramName
@throws \common_exception_MissingParameter
@return string
960999
protected function getRawParameter($paramName)
    {
        $raw = $this->getRequest()->getRawParameters();
        if (!isset($raw[$paramName])) {
            throw new \common_exception_MissingParameter($paramName);
        }
        return $raw[$paramName];
    }
606230
public function getTrackingParameter($parameterName)
    {
        $trackingParameters = $this->persister->getAllTrackingParameters();

        if (null !== $parameterValue = $trackingParameters->get($parameterName)) {
            return $parameterValue;
        }

        if (0 === $this->allTrackingParameters->count()) {
            $this->allTrackingParameters = clone $trackingParameters;

            foreach ($this->formatters as $formatter) {
                $newParameters = $formatter->format($trackingParameters);

                foreach ($newParameters as $newParameterName => $newParameterValue) {
                    $this->allTrackingParameters->set($newParameterName, $newParameterValue);
                }
            }
        }

        if (null !== $parameterValue = $this->allTrackingParameters->get($parameterName)) {
            return $parameterValue;
        }

        return null;
    }
217639
protected function getResourceParameter()
    {
        if (! $this->hasRequestParameter(self::RESOURCE_PARAMETER)) {
            throw new \common_exception_MissingParameter(self::RESOURCE_PARAMETER, __CLASS__);
        }

        $uri = $this->getRequestParameter(self::RESOURCE_PARAMETER);
        if (empty($uri) || !common_Utils::isUri($uri)) {
            throw new \common_exception_MissingParameter(self::RESOURCE_PARAMETER, __CLASS__);
        }

        return $this->getResource($uri);
    }
1158320
private function getParameterFromContext(array $context, string $parameterName, $default = null)
    {
        $filters = $context['filters'] ?? [];

        return \array_key_exists($parameterName, $filters) ? $filters[$parameterName] : $default;
    }
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 . "'");
        }
    }
349684
public function getParam($param)
    {
        if (!is_string($param)) {
            throw new \Erebot\InvalidValueException('Bad parameter name');
        }
        if (!isset($this->params[$param])) {
            throw new \Erebot\NotFoundException('No such parameter');
        }
        return $this->params[$param];
    }
1252935
private function parseParameter(string $key, string $value, &$params): string
    {
        if (isset($params[$key])) {
            $par = $params[$key];
            unset($params[$key]);

            $value = $value ? $value . '_' . $par : $par;
        }

        return static::makeParam($key, $value);
    }
1237707
public function get($name)
    {
        if (!isset($this->parameters[$name])) {
            throw new ParameterNotFoundException("The requested parameter '{$name}' doesn't exist.");
        }

        return $this->parameters[$name];
    }
953589
protected function getValueFromParameterString($name, $paramString, $value)
    {
        $original = $paramString;

        while (preg_match('@^(\[([^\]]+)\])@', $paramString, $matches)) {
            $key = $matches[2];
            $paramString = str_replace($matches[1], '', $paramString);

            if (!isset($value[$key])) {
                throw new Exception\ParameterKeyDoesNotExistException($name, $original);
            }

            $value = $value[$key];

            if (empty($paramString)) {
                break;
            }
        }

        return $value;
    }
1027899
protected function _params2string($params)
    {
        if (!count($params)) {
            return '';
        }
        $paramsPart = array();
        foreach ($params as $name => $value) {
            if (!$value && ('0' !== $value)) {
                continue;
            }
            $paramsPart[] = str_replace(array('{name}', '{value}'), array($name, urlencode($value)), $this->paramsPairStructure);
        }
        if (!count($paramsPart)) {
            return '';
        }
        return '/' . implode($this->paramsSeparator, $paramsPart);
    }
793719
public function getParameter(string $parameterName): Parameter
    {
        if (!$this->hasParameter($parameterName)) {
            throw ParameterException::noParameter($parameterName);
        }

        return $this->parameters[$parameterName];
    }
339304
public function getParameterDescription(ReflectionParameter $param): ?string
    {
        $name = preg_quote($param->getName());

        if (preg_match('~@param\h+\H+\h+\$' . $name . '\h+(.*)~', $this->comment, $m)) {
            return ucfirst(trim($m[1]));
        }

        return null;
    }
569341
private function getDefaultValue(\ReflectionParameter $param)
    {
        if ($param->isDefaultValueAvailable()) {
            if (method_exists($param, 'isDefaultValueConstant') && $param->isDefaultValueConstant()) {
                $constName = $param->getDefaultValueConstantName();
                if (false !== strpos($constName, '::')) {
                    list($class, $const) = explode('::', $constName);
                    if (in_array($class, ['self', 'static'])) {
                        $constName = $param->getDeclaringClass()->getName().'::'.$const;
                    }
                }

                return $constName;
            }

            return $this->phpEncodeValue($param->getDefaultValue());
        }

        return 'null';
    }
584471
public String getParamString(String paramName) {
        Object paramValue = getParam(paramName);
        if (paramValue == null) {
            return null;
        }
        return paramValue.toString();
    }
1129567
public function getParam(string $param)
    {
        if (! empty($this->match['params'][$param])) {
            return $this->match['params'][$param];
        }
    }
537189
public function param($name = '')
    {
        switch ($this->method) {
            case 'POST':
                $data = $this->post();
                break;
            case 'GET':
                $data = $this->get();
                break;
        }

        if (empty($name)) {
            return $data;
        } else {
            return isset($data[$name]) ? $data[$name] : null;
        }
    }
1201573
public function value(string $paramName): Value
    {
        return Value::of($this->params[$paramName] ?? null);
    }