@param string $parameterName

@return null|Money
@throws InvalidRequestException
504086
public function getMoney($parameterName = 'amount')
    {
        $amount = $this->getParameter($parameterName);

        if ($amount instanceof Money) {
            return $amount;
        }

        if ($amount !== null) {
            $moneyParser = new DecimalMoneyParser($this->getCurrencies());
            $currencyCode = $this->getCurrency() ?: 'USD';
            $currency = new Currency($currencyCode);

            $number = Number::fromString($amount);

            // Check for rounding that may occur if too many significant decimal digits are supplied.
            $decimal_count = strlen($number->getFractionalPart());
            $subunit = $this->getCurrencies()->subunitFor($currency);
            if ($decimal_count > $subunit) {
                throw new InvalidRequestException('Amount precision is too high for currency.');
            }

            $money = $moneyParser->parse((string) $number, $currency->getCode());

            // Check for a negative amount.
            if (!$this->negativeAmountAllowed && $money->isNegative()) {
                throw new InvalidRequestException('A negative amount is not allowed.');
            }

            // Check for a zero amount.
            if (!$this->zeroAmountAllowed && $money->isZero()) {
                throw new InvalidRequestException('A zero amount is not allowed.');
            }

            return $money;
        }
    }
43485
public function getParameter($parameterName)
    {
        $value = $this->parameters->resolve($parameterName);

        if ($value instanceof ArrayResolver) {
            return $value->extract();
        }

        return $value;
    }
464911
public function validate()
    {
        foreach (func_get_args() as $key) {
            $value = $this->parameters->get($key);
            if (empty($value) && $value !== '0' && $value !== false) {
                throw new InvalidRequestException("The $key parameter is required");
            }
        }
    }
586213
public function getParameter($name)
    {
        if (!array_key_exists($name, $this->parameters)) {
            throw new InvalidArgumentException(sprintf('Parameter: "%s" does not exist', $name));
        }

        return $this->parameters[$name];
    }
74626
public function getParam(string $paramName)
	{
		return $this->hasParam($paramName) ? $this->params[ $paramName ] : null;
	}
1194842
public function convertToSql(String $query, Parameters $parameterRepository) : StdClass
	{
		$stdClass = new StdClass();
		$stdClass->parameterValues = [];
		$placeholder = '?';
		$stdClass->query = '';
		$match = false;

		if (preg_match_all('/\:([^ ,]+)/s', $query, $matched)) {
			$stdClass->parameterValues = array_map(function($value) use ($parameterRepository, $matched) {
				$value = str_replace(',', '', $value);
				if ($parameterRepository->getParameter($value) == null) {
					throw new InvalidParameterCountException(
						'Number of parameters does not match length of proposed parameters.',
						$matched[1],
						$parameterRepository
					);
				}

				return $parameterRepository->getParameter($value);
			}, $matched[1]);
		}

		$stdClass->query = str_replace($matched[0], '?', $query);

		if (sizeof($stdClass->parameterValues) < 1) {
			$stdClass->parameterValues = array_values($parameterRepository->getAll());
		}

		return $stdClass;
	}
924338
public static QueryParameter getParameterByName(List<QueryParameter> params, String parameterName) {
        for (QueryParameter parameter : params) {
            if (parameter.getName().equals(parameterName)) {
                return parameter;
            }
        }
        return null;
    }
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];
    }
641967
public function getParameterDefinition(string $parameterName): ParameterDefinition
    {
        if (!$this->hasParameterDefinition($parameterName)) {
            throw ParameterException::noParameterDefinition($parameterName);
        }

        return $this->parameterDefinitions[$parameterName];
    }
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);
    }
1105955
public function get($parameterName, $defaultValue = null, $deep = false)
    {
        return $this->params->get($parameterName, $defaultValue, $deep);
    }
1173229
public function getParam($key)
    {
        if (!$this->hasParam($key)) {
            throw new InvalidException('Param '.$key.' does not exist');
        }

        return $this->_params[$key];
    }
436094
public function getFormDefinedUrl($parameterName, $default = null)
    {
        $formDefinedUrl = $this->form->get($parameterName)->getData();

        if (empty($formDefinedUrl)) {
            if ($default === null) {
                $default = ConfigQuery::read('base_url', '/');
            }

            $formDefinedUrl = $default;
        }

        return URL::getInstance()->absoluteUrl($formDefinedUrl);
    }
742461
protected function getCurrentInstance($parameterName = 'uri')
    {
        $uri = tao_helpers_Uri::decode($this->getRequestParameter($parameterName));

        $this->validateUri($uri);

        return $this->getResource($uri);
    }
340544
@Override
	public Parameter getParam(final String paramName) {
		Parameter param = getBindParameter(paramName);
		if (param == null) {
			Map<String, Parameter> constParams = getConstParameterMap();
			if (constParams != null) {
				param = constParams.get(paramName.toUpperCase());
			}
		}
		return param;
	}
1351557
public function hasConstructorParameter($parameterName)
    {
        $hasConstructorParameter = false;

        if (($ctor = $this->getClass()->getConstructor()) !== null) {

            foreach ($ctor->getParameters() as $param) {
                if ($param->getName() === $parameterName && $this->hasProperty($param->getName()) === true) {
                    $hasConstructorParameter = true;
                    break;
                }
            }
        }

        return $hasConstructorParameter;
    }
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;
        }
    }