{@inheritdoc}

@param bool|int|float $parameter
504459
public function resolve(Parameter $parameter, ParameterBag $unresolvedParameters, ParameterBag $resolvedParameters): ParameterBag
    {
        return $resolvedParameters->with($parameter);
    }
948298
public function setParameters($parameters)
    {
        parent::setParameters($parameters);
        if ($parameters !== null) {
            for ($i = 0, $size = count($parameters); $i < $size; $i++) {
                $paramname = $parameters[$i]->getName();
                if (self::TYPE_KEY == strtolower($paramname)) {
                    $this->setType($parameters[$i]->getValue());
                } else {
                    $this->setError("Invalid parameter " . $paramname);
                }
            }
        }
    }
44246
protected function fixupParameter( &$parameter )
    {
        if ( is_array( $parameter ) )
        {
            foreach ( $parameter as &$subParameter )
            {
                $this->fixupParameter( $subParameter );
            }
        }

        if ( $parameter instanceof stdClass )
        {
            if ( isset( $parameter->xmlrpc_type ) && $parameter->xmlrpc_type == 'datetime' )
            {
                $parameter = new DateTime( date( "Ymd\TH:i:s", $parameter->timestamp ) );
            }
            else if ( isset( $parameter->xmlrpc_type ) && $parameter->xmlrpc_type == 'base64' )
            {
                $parameter = (string)$parameter->scalar;
            }
        }
    }
230748
public function isBlobParameter(?array $parameters): bool
  {
    $hasBlob = false;

    if ($parameters)
    {
      foreach ($parameters as $parameter_info)
      {
        $hasBlob = $hasBlob || DataTypeHelper::isBlobParameter($parameter_info['data_type']);
      }
    }

    return $hasBlob;
  }
1277046
public function registerParameters($parameters)
	{
		foreach ($parameters as $parameter => $value) {
			if (property_exists($this, $parameter)) {
				$this->$parameter = $value;
			}
		}
	}
1333482
public function setParameter(string $parameter, string $value): self
    {
        $this->parameters[$parameter] = $value;

        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;

    }
514046
public function setParameters($parameters)
    {
        parent::setParameters($parameters);
        if ($parameters !== null) {
            for ($i = 0, $size = count($parameters); $i < $size; $i++) {
                $paramname = $parameters[$i]->getName();
                switch (strtolower($paramname)) {
                    case self::MIN_KEY:
                        $this->setMin($parameters[$i]->getValue());
                        break;
                    case self::MAX_KEY:
                        $this->setMax($parameters[$i]->getValue());
                        break;

                    default:
                        $this->setError("Invalid parameter " . $paramname);
                } // switch
            }
        }
    }
1123554
private function isSolvable(\ReflectionParameter $parameter): bool
    {

        if ($parameter->getType() == null && !$parameter->isOptional()) {
            return false;
        }

        $reflection = new \ReflectionClass($parameter->getType()->getName());
        if (!$reflection->isInstantiable()) {
            return false;
        }

        return true;
    }
702045
public function get($parameter = null) {

        if ( empty($parameter) ) {

            $return = $this->parameters;

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

            $return = $this->parameters[$parameter];

        } else {

            $return = null;

        }

        return $return;

    }
1132238
private function transformToScalar(string $parameter, string $type)
    {
        switch ($type) {
            case 'int':
                $parameter = (int) $parameter;

                break;
            case 'bool':
                //TODO : utiliser plutot ce bout de code (il faudra surement faire un lowercase en plus !!!) :     \in_array(\trim($value), ['1', 'true'], true);
                $parameter = (bool) $parameter;

                break;
            case 'float':
                $parameter = (float) $parameter;

                break;
        }

        return $parameter;
    }
1009858
public function processParameter($parameter)
    {
        foreach ($this->getParameterProcessors() as $processor) {
            if ($processor->doesHandle($parameter)) {
                return $processor->process($parameter);
            }
        }

        return $parameter;
    }
509335
public function having($condition, $parameter = [])
	{
		$this->emptyResult();
		$this->queryBuilder->addHaving($condition, $parameter);
		return $this;
	}
583892
public static function typehint($parameter)
    {
        $typehint = '';
        if ($parameter->getClass()) {
            $typehint = '\\' . $parameter->getClass()->getName();
        } elseif (preg_match('/.*?\[ \<[^\>]+\> (?:HH\\\)?(\w+)(.*?)\$/', (string) $parameter, $match)) {
            $typehint = $match[1];
            if ($typehint === 'integer') {
                $typehint = 'int';
            } elseif ($typehint === 'boolean') {
                $typehint = 'bool';
            } elseif ($typehint === 'mixed') {
                $typehint = '';
            }
        }
        return $typehint;
    }
371240
private static function matchType(\ReflectionParameter $parameter, $value) : bool
    {
        if ($class = $parameter->getClass()) {
            return \is_object($value) && $class->isInstance($value);
        }

        if ($parameter->isArray()) {
            return \is_array($value);
        }

        if ($parameter->isCallable()) {
            return \is_callable($value);
        }

        if (!$type = $parameter->getType()) {
            return true;
        }

        switch ($type->getName()) {
            case 'bool': return \is_bool($value);
            case 'float': return \is_float($value);
            case 'int': return \is_int($value);
            case 'string': return \is_string($value);
            case 'iterable': return \is_iterable($value);
        }

        return true;
    }
2541
public function addParameter($name, $parameter)
  {
    if ($this->isLocked()) {
      return $this->getObj()->addParameter($name, $parameter)->setLocked();
    } else {
      return parent::addParameter($name, $parameter);
    }
  }
295666
private function isVariadic(\ReflectionParameter $parameter)
    {
        if ($parameter->name == "...") {
            // This is a variadic C-implementation before PHP-5.6.
            return true;
        }
        if (method_exists($parameter, "isVariadic")) {
            return $parameter->isVariadic();
        }
        return false;
    }