returns request value from params for filtering or validation

@param   string  $paramName  name of parameter
@return  \stubbles\input\ValueReader
@since   1.3.0
426097
public function readParam(string $paramName): ValueReader
    {
        return new ValueReader(
                $this->params->errors(),
                $paramName,
                $this->params->value($paramName)
        );
    }
76185
public function loadRequestPath($paramName)
    {
        // parse from the end to the top
        $path = array_reverse(explode('/', $this->contextRequestPath));

        /**
         * -1 => current params
         * -2 => method
         * -3 => route
         */
        $datapath     = $this->__get('DataPath');
        $partDataPath = null;

        while (true) {
            if (!is_array($datapath) || empty($datapath)) {
                $partDataPath = null;
                break;
            }

            $partDataPath = array_pop($datapath);

            if (substr($partDataPath, 0, 1) == '/') {
                break;
            }
        }

        // parse from the end to the top
        $route = array_reverse(explode('/', $partDataPath));

        foreach ($route as $key => $partRoute) {

            if ($partRoute != '{' . $paramName . '}') {
                continue;
            }

            if (!array_key_exists($key, $path)) {
                $this->contextDataExists = false;
                $this->contextDataValue  = null;
                break;
            }

            $this->contextDataExists = true;
            $this->contextDataValue  = urldecode($path[$key]);
        }

        return $this->checkDataIsEmpty();
    }
591412
public function get($methodName, array $params = array())
    {
        $options = array_merge($this->defaultApiOptions, $this->createConfigByMethodName($methodName));
        $options['http'] = 'get';
        return $this->internalCall($methodName, $options, $params);
    }
177151
public function getGetParamValue($name, $ignoreCase = false)
    {
        if ($ignoreCase)
        {
            $name = strtolower($name);
            foreach ($this->getParams as $key => $value)
            {
                if (strtolower($key) === $name)
                {
                    return $value;
                }
            }
        }
        else
        {
            foreach ($this->getParams as $key => $value)
            {
                if ($key === $name)
                {
                    return $value;
                }
            }
        }
        return null;
    }
584471
public String getParamString(String paramName) {
        Object paramValue = getParam(paramName);
        if (paramValue == null) {
            return null;
        }
        return paramValue.toString();
    }
34915
public UploadFile getFile(String paramName) {
		UploadFile[] values = getFiles(paramName);
		if ((values != null) && (values.length > 0)) {
			return values[0];
		}
		return null;
	}
355048
final protected function getValueFromParam(string $param)
  {
    if (preg_match(self::$regEx['match'], $param)) {
      $arg = preg_filter(self::$regEx['filter'], '', $param);
      if (preg_match(self::$regEx['config'], $arg)) {
        return $this->getValueFromConfig($arg);
      } elseif (preg_match(self::$regEx['array'], $arg)) {
        return $this->getValueFromArray($arg);
      } else {
        return Fixtures::get($arg);
      }
    } else {
      return $param;
    }
  }
694451
public function readEnv(string $envName): ValueReader
    {
        return new ValueReader(
                $this->env->errors(),
                $envName,
                $this->env->value($envName)
        );
    }
235951
public function getParameterValue(string $parameterName)
    {
        if (!$this->hasParameterValue($parameterName)) {
            return null;
        }

        return $this->parameterValues[$parameterName];
    }
490736
public function addParameterByName($paramName)
	{
		if (array_key_exists($paramName, $this->params))
		{
			throw new InvalidArgumentException("Parameter '" . $paramName . "' already exists");
		}

		$this->params[$paramName] = null;

		return $this;
	}
935660
public function getParam($paramName)
    {
        return !empty($this->_params[$paramName]) ? $this->_params[$paramName] : NULL;
    }
536153
public function withQueryParameter(string $parameterName, $value): InternalRequest
    {
        $query = $this->modifyQueryParameter(
            $this->uri->getQuery() ?? '',
            $parameterName,
            $value
        );

        $target = clone $this;
        $target->uri = $target->uri->withQuery($query);
        return $target;
    }
1210457
private function getParameter($paramName)
	{
		if (array_key_exists($paramName, $_REQUEST))
		{
			return str_replace(FileUtil::Slash().FileUtil::Slash(), FileUtil::Slash(), $_REQUEST[$paramName]);
		}
		else
		{
			return "";
		}
	}
831937
public function getRequestEscapedParameter($name, $defaultValue = null)
    {
        $value = $this->getRequestParameter($name, $defaultValue);

        // TODO: remove this after special chars concept implementation
        $isAdmin = Registry::getConfig()->isAdmin() && Registry::getSession()->getVariable("blIsAdmin");
        if ($value !== null && !$isAdmin) {
            $this->checkParamSpecialChars($value);
        }

        return $value;
    }
341798
public String getFirstParam(String paramName) {
        Collection<String> values = this.params.get(paramName);
        if(values == null || values.isEmpty()) {
            return null;
        } else {
            return values.iterator().next();
        }
    }
704128
protected function getParameterModel($paramName, $modelClassName, $requestParams)
    {
        $paramModel = new $modelClassName;

        if (!$paramModel instanceof \yii\base\Model) {
            throw new \yii\base\InvalidParamException("Parameter '{$paramName}' must be instance of \yii\base\Model");
        }

        if (in_array($this->scenario, $paramModel->scenarios())) {
            $paramModel->scenario = $this->scenario;
            $paramModel->setAttributes($requestParams[$paramName], true);
        } else {
            $paramModel->setAttributes($requestParams[$paramName], false);
        }

        if (!$paramModel->validate()) {
            throw new ValidationException('Invalid JSON-RPC request parameters.', 0, $paramModel->getErrors());
        }

        return $paramModel;
    }
1119686
public function getRequestReader ($queueName) 
    {
        $forwardQueueName = $this->_prepareQueueName($queueName);
        
        $server = $this->_getServerOrFail($forwardQueueName, RouterConfig::SERVER_TAG_DEFAULT);
    
        return $server->getReplyReader(self::THREAD_MAIN, $this->replyQueueName, RouterConfig::CONFIG_REPLY_CONSUMER);
    }