@param string $parameter

@return mixed
174213
public function getParameter(string $parameter)
    {
        if ($this->hasParameter($parameter)) {
            return $this->getParameters()[$parameter];
        }

        throw new \InvalidArgumentException(sprintf('Parameter "%s" does not exist', $parameter));
    }
1023385
private function parameters($parameters): array
    {
        $values = (!is_array($parameters)) ? [$parameters] : $parameters;

        $strings = [];

        foreach ($values as $value) {
            $strings[] = self::make($value, $this->encoding);
        }

        return $strings;
    }
878145
protected function parameterAllowsGuests($parameter)
    {
        return ($parameter->getClass() && $parameter->allowsNull()) ||
               ($parameter->isDefaultValueAvailable() && is_null($parameter->getDefaultValue()));
    }
310012
protected function getParameter(\ReflectionParameter $parameter)
    {
        if ($parameter->isOptional()) {
            return $parameter->getDefaultValue();
        }

        $type = (string)$parameter->getType();
        return $this->get($type);
    }
828787
public function with(Parameter $parameter): self
    {
        $key = $parameter->getKey();

        $clone = clone $this;
        if (false === $clone->has($key)) {
            $clone->parameters[$key] = $parameter->getValue();
        }

        return $clone;
    }
815995
protected function wrapPHPValue($parameter)
    {
        switch ($parameter['default']['type']) {
            case 'null':
                return 'null';
                break;

            case 'string':
            case 'char':
                return '\''.addslashes($parameter['default']['value']).'\'';
                break;

            case 'empty-array':
                return 'array()';
                break;

            case 'array':
                $parameters = [];

                foreach ($parameter['default']['left'] as $value) {
                    $source = '';

                    if (isset($value['key'])) {
                        $source .= $this->wrapPHPValue([
                            'default' => $value['key'],
                            'type' => $value['key']['type'],
                        ]).' => ';
                    }

                    $parameters[] = $source.$this->wrapPHPValue([
                        'default' => $value['value'],
                        'type' => $value['value']['type'],
                    ]);
                }

                return 'array('.implode(', ', $parameters).')';
                break;

            case 'static-constant-access':
                return $parameter['default']['left']['value'].'::'.$parameter['default']['right']['value'];
                break;

            case 'int':
            case 'double':
            case 'bool':
                return $parameter['default']['value'];
                break;

            default:
                throw new Exception('Stubs - value with type: '.$parameter['default']['type'].' is not supported');
                break;
        }
    }
633486
protected static function getParameterTypeHint(\ReflectionParameter $parameter) : string
    {
        if ($parameter->getClass()) {
            if (
                $parameter->allowsNull()
                && version_compare(PHP_VERSION, '7.1.0', '>=')) {
                return '?\\' . $parameter->getClass()->getName();
            }

            return '\\' . $parameter->getClass()->getName();
        } elseif ($parameter->hasType()) {
            $type = $parameter->getType();

            if (
                $type->allowsNull()
                && $type->__toString()[0] !== '?'
                && version_compare(PHP_VERSION, '7.1.0', '>=')) {
                return '?' . $type->__toString();
            }

            return $type->__toString();
        } else {
            return '';
        }
    }
891486
public function has($parameter) {

        return is_null($this->getFromParts(self::splitParts($parameter))) ? false : true;

    }
875564
public function configHas($parameter)
    {
        if (empty($this->config)) {
            return false;
        }

        return $this->config->has($parameter);
    }
274309
private function getParameterType(\ReflectionParameter $parameter)
    {
        if ( ! $parameter->hasType()) {
            return null;
        }

        return $this->formatType($parameter->getType(), $parameter->getDeclaringFunction(), $parameter);
    }
849214
public function delete($parameter = null) {

        if ( is_null($parameter) ) {

            $this->parameters = [];

            return true;

        } else if ( array_key_exists($parameter, $this->parameters) ) {

            unset($this->parameters[$parameter]);

            return true;

        } else {

            return false;

        }

    }
309548
private function formatParameter(ReflectionParameter $parameter): string
    {
        return $parameter->hasType() ?
            sprintf('%s $%s', $parameter->getType(), $parameter->getName()) :
            sprintf('$%s', $parameter->getName());
    }
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;
    }
972536
public static function explodeSortParameter($parameter)
    {
        $separator = config('columnsortable.uri_relation_column_separator', '.');

        if (str_contains($parameter, $separator)) {
            $oneToOneSort = explode($separator, $parameter);
            if (count($oneToOneSort) !== 2) {
                throw new ColumnSortableException();
            }

            return $oneToOneSort;
        }

        return [];
    }
221736
protected function parseArgument($parameter)
    {
        if ($this->commandNameEnabled && !$this->commandName) {
            $this->commandName = $parameter;
        } else {
            $this->arguments[] = $parameter;
        }
        return $this;
    }
994718
public function getParameter( $parameter )
    {

        self::isParameterAllowed( $parameter );

        $value = $this->query(new Raw("SHOW {$parameter}"))->fetch( Result::FETCH_SINGLE );

        return ( $value === 'true' or $value === 'false' )
            ? \Bond\boolval( $value )
            : $value;

    }
718328
public function configParam($parameter)
    {
        $value = $this->container->getParameter($parameter);

        return is_array($value) ? json_encode($value) : $value;
    }